@nodert-win10-rs4/windows.ui.xaml.controls/lib/NodeRT_Windows_UI_Xaml_Controls.d.ts

Use the Windows.UI.Xaml.Controls UWP API directly from Node.js

declare module "windows.ui.xaml.controls" {
  export class Color {
    constructor();
  }

  export class Point {
    constructor();
  }

  export class Rect {
    constructor();
  }

  export class GeneratorPosition {
    constructor();
  }

  export class TextRange {
    startIndex: Number;
    length: Number;
    constructor();
  }

  export class Thickness {
    constructor();
  }

  export class GridLength {
    constructor();
  }

  export class FontWeight {
    weight: Number;
    constructor();
  }

  export class Size {
    constructor();
  }

  export class CornerRadius {
    constructor();
  }

  export class Duration {
    constructor();
  }

  export class LoadMoreItemsResult {
    count: Number;
    constructor();
  }

  export enum ColorSpectrumShape {
    box,
    ring,
  }

  export enum ColorSpectrumComponents {
    hueValue,
    valueHue,
    hueSaturation,
    saturationHue,
    saturationValue,
    valueSaturation,
  }

  export enum ColorPickerHsvChannel {
    hue,
    saturation,
    value,
    alpha,
  }

  export enum NavigationViewDisplayMode {
    minimal,
    compact,
    expanded,
  }

  export enum NavigationViewBackButtonVisible {
    collapsed,
    visible,
    auto,
  }

  export enum ParallaxSourceOffsetKind {
    absolute,
    relative,
  }

  export enum RefreshVisualizerOrientation {
    auto,
    normal,
    rotate90DegreesCounterclockwise,
    rotate270DegreesCounterclockwise,
  }

  export enum RefreshVisualizerState {
    idle,
    peeking,
    interacting,
    pending,
    refreshing,
  }

  export enum RefreshPullDirection {
    leftToRight,
    topToBottom,
    rightToLeft,
    bottomToTop,
  }

  export enum SwipeBehaviorOnInvoked {
    auto,
    close,
    remainOpen,
  }

  export enum SwipeMode {
    reveal,
    execute,
  }

  export enum TreeViewSelectionMode {
    none,
    single,
    multiple,
  }

  export enum CandidateWindowAlignment {
    default,
    bottomEdge,
  }

  export enum CharacterCasing {
    normal,
    lower,
    upper,
  }

  export enum ClickMode {
    release,
    press,
    hover,
  }

  export enum ComboBoxSelectionChangedTrigger {
    committed,
    always,
  }

  export enum DisabledFormattingAccelerators {
    none,
    bold,
    italic,
    underline,
    all,
  }

  export enum HandwritingPanelPlacementAlignment {
    auto,
    topLeft,
    topRight,
    bottomLeft,
    bottomRight,
  }

  export enum IncrementalLoadingTrigger {
    none,
    edge,
  }

  export enum ItemsUpdatingScrollMode {
    keepItemsInView,
    keepScrollOffset,
    keepLastItemInView,
  }

  export enum ListViewReorderMode {
    disabled,
    enabled,
  }

  export enum ListViewSelectionMode {
    none,
    single,
    multiple,
    extended,
  }

  export enum Orientation {
    vertical,
    horizontal,
  }

  export enum PanelScrollingDirection {
    none,
    forward,
    backward,
  }

  export enum PasswordRevealMode {
    peek,
    hidden,
    visible,
  }

  export enum RichEditClipboardFormat {
    allFormats,
    plainText,
  }

  export enum ScrollBarVisibility {
    disabled,
    auto,
    hidden,
    visible,
  }

  export enum ScrollIntoViewAlignment {
    default,
    leading,
  }

  export enum ScrollMode {
    disabled,
    enabled,
    auto,
  }

  export enum SelectionMode {
    single,
    multiple,
    extended,
  }

  export enum SnapPointsType {
    none,
    optional,
    mandatory,
    optionalSingle,
    mandatorySingle,
  }

  export enum StretchDirection {
    upOnly,
    downOnly,
    both,
  }

  export enum VirtualizationMode {
    standard,
    recycling,
  }

  export enum ZoomMode {
    disabled,
    enabled,
  }

  export enum AppBarClosedDisplayMode {
    compact,
    minimal,
    hidden,
  }

  export enum AutoSuggestionBoxTextChangeReason {
    userInput,
    programmaticChange,
    suggestionChosen,
  }

  export enum CalendarViewDisplayMode {
    month,
    year,
    decade,
  }

  export enum CalendarViewSelectionMode {
    none,
    single,
    multiple,
  }

  export enum CommandBarDefaultLabelPosition {
    bottom,
    right,
    collapsed,
  }

  export enum CommandBarDynamicOverflowAction {
    addingToOverflow,
    removingFromOverflow,
  }

  export enum CommandBarLabelPosition {
    default,
    collapsed,
  }

  export enum CommandBarOverflowButtonVisibility {
    auto,
    visible,
    collapsed,
  }

  export enum ContentDialogButton {
    none,
    primary,
    secondary,
    close,
  }

  export enum ContentDialogPlacement {
    popup,
    inPlace,
  }

  export enum ContentDialogResult {
    none,
    primary,
    secondary,
  }

  export enum ContentLinkChangeKind {
    inserted,
    removed,
    edited,
  }

  export enum SplitViewDisplayMode {
    overlay,
    inline,
    compactOverlay,
    compactInline,
  }

  export enum SplitViewPanePlacement {
    left,
    right,
  }

  export enum Symbol {
    previous,
    next,
    play,
    pause,
    edit,
    save,
    clear,
    delete,
    remove,
    add,
    cancel,
    accept,
    more,
    redo,
    undo,
    home,
    up,
    forward,
    back,
    favorite,
    camera,
    setting,
    video,
    sync,
    download,
    mail,
    find,
    help,
    upload,
    emoji,
    twoPage,
    leaveChat,
    mailForward,
    clock,
    send,
    crop,
    rotateCamera,
    people,
    openPane,
    closePane,
    world,
    flag,
    previewLink,
    globe,
    trim,
    attachCamera,
    zoomIn,
    bookmarks,
    document,
    protectedDocument,
    page,
    bullets,
    comment,
    mailFilled,
    contactInfo,
    hangUp,
    viewAll,
    mapPin,
    phone,
    videoChat,
    switch,
    contact,
    rename,
    pin,
    musicInfo,
    go,
    keyboard,
    dockLeft,
    dockRight,
    dockBottom,
    remote,
    refresh,
    rotate,
    shuffle,
    list,
    shop,
    selectAll,
    orientation,
    import,
    importAll,
    browsePhotos,
    webCam,
    pictures,
    saveLocal,
    caption,
    stop,
    showResults,
    volume,
    repair,
    message,
    page2,
    calendarDay,
    calendarWeek,
    calendar,
    character,
    mailReplyAll,
    read,
    link,
    account,
    showBcc,
    hideBcc,
    cut,
    attach,
    paste,
    filter,
    copy,
    emoji2,
    important,
    mailReply,
    slideShow,
    sort,
    manage,
    allApps,
    disconnectDrive,
    mapDrive,
    newWindow,
    openWith,
    contactPresence,
    priority,
    goToToday,
    font,
    fontColor,
    contact2,
    folder,
    audio,
    placeholder,
    view,
    setLockScreen,
    setTile,
    closedCaption,
    stopSlideShow,
    permissions,
    highlight,
    disableUpdates,
    unFavorite,
    unPin,
    openLocal,
    mute,
    italic,
    underline,
    bold,
    moveToFolder,
    likeDislike,
    dislike,
    like,
    alignRight,
    alignCenter,
    alignLeft,
    zoom,
    zoomOut,
    openFile,
    otherUser,
    admin,
    street,
    map,
    clearSelection,
    fontDecrease,
    fontIncrease,
    fontSize,
    cellPhone,
    reShare,
    tag,
    repeatOne,
    repeatAll,
    outlineStar,
    solidStar,
    calculator,
    directions,
    target,
    library,
    phoneBook,
    memo,
    microphone,
    postUpdate,
    backToWindow,
    fullScreen,
    newFolder,
    calendarReply,
    unSyncFolder,
    reportHacked,
    syncFolder,
    blockContact,
    switchApps,
    addFriend,
    touchPointer,
    goToStart,
    zeroBars,
    oneBar,
    twoBars,
    threeBars,
    fourBars,
    scan,
    preview,
    globalNavigationButton,
    share,
    print,
    xboxOneConsole,
  }

  export enum WebViewExecutionMode {
    sameThread,
    separateThread,
    separateProcess,
  }

  export enum WebViewPermissionState {
    unknown,
    defer,
    allow,
    deny,
  }

  export enum WebViewPermissionType {
    geolocation,
    unlimitedIndexedDBQuota,
    media,
    pointerLock,
    webNotifications,
    screen,
    immersiveView,
  }

  export enum LightDismissOverlayMode {
    auto,
    on,
    off,
  }

  export enum RequiresPointer {
    never,
    whenEngaged,
    whenFocused,
  }

  export enum InkToolbarButtonFlyoutPlacement {
    auto,
    top,
    bottom,
    left,
    right,
  }

  export enum InkToolbarFlyoutItemKind {
    simple,
    radio,
    check,
    radioCheck,
  }

  export enum InkToolbarInitialControls {
    all,
    none,
    pensOnly,
    allExceptPens,
  }

  export enum InkToolbarMenuKind {
    stencil,
  }

  export enum InkToolbarStencilKind {
    ruler,
    protractor,
  }

  export enum InkToolbarToggle {
    ruler,
    custom,
  }

  export enum InkToolbarTool {
    ballpointPen,
    pencil,
    highlighter,
    eraser,
    customPen,
    customTool,
  }

  export enum ListPickerFlyoutSelectionMode {
    single,
    multiple,
  }

  export enum PivotHeaderFocusVisualPlacement {
    itemHeaders,
    selectedItemHeader,
  }

  export enum PivotSlideInAnimationGroup {
    default,
    groupOne,
    groupTwo,
    groupThree,
  }

  export class ColorChangedEventArgs {
    newColor: Object;
    oldColor: Object;
    constructor();

  }

  export class NavigationViewDisplayModeChangedEventArgs {
    displayMode: NavigationViewDisplayMode;
    constructor();

  }

  export class NavigationViewSelectionChangedEventArgs {
    isSettingsSelected: Boolean;
    selectedItem: Object;
    constructor();

  }

  export class NavigationViewItemInvokedEventArgs {
    invokedItem: Object;
    isSettingsInvoked: Boolean;
    constructor();

  }

  export class NavigationViewPaneClosingEventArgs {
    cancel: Boolean;
    constructor();

  }

  export class NavigationViewBackRequestedEventArgs {
    constructor();

  }

  export class RefreshInteractionRatioChangedEventArgs {
    interactionRatio: Number;
    constructor();

  }

  export class RefreshRequestedEventArgs {
    constructor();

    getDeferral(): Object;

  }

  export class RefreshStateChangedEventArgs {
    newState: RefreshVisualizerState;
    oldState: RefreshVisualizerState;
    constructor();

  }

  export class SwipeItemInvokedEventArgs {
    swipeControl: SwipeControl;
    constructor();

  }

  export class TreeViewItemInvokedEventArgs {
    handled: Boolean;
    invokedItem: Object;
    constructor();

  }

  export class TreeViewExpandingEventArgs {
    node: TreeViewNode;
    constructor();

  }

  export class TreeViewCollapsedEventArgs {
    node: TreeViewNode;
    constructor();

  }

  export class BackClickEventArgs {
    handled: Boolean;
    constructor();

  }

  export class DragItemsStartingEventArgs {
    cancel: Boolean;
    data: Object;
    items: Object;
    constructor();

  }

  export class NotifyEventArgs {
    value: String;
    callingUri: Object;
    constructor();

  }

  export class SemanticZoomViewChangedEventArgs {
    sourceItem: SemanticZoomLocation;
    isSourceZoomedInView: Boolean;
    destinationItem: SemanticZoomLocation;
    constructor();

  }

  export class TextControlPasteEventArgs {
    handled: Boolean;
    constructor();

  }

  export class ContainerContentChangingEventArgs {
    handled: Boolean;
    inRecycleQueue: Boolean;
    item: Object;
    itemContainer: Object;
    itemIndex: Number;
    phase: Number;
    constructor();

    registerUpdateCallback(callback: Object): void;
    registerUpdateCallback(callbackPhase: Number, callback: Object): void;

  }

  export class IInsertionPanel {
    constructor();

    getInsertionIndexes(position: Object, first: Number, second: Number): void;

  }

  export class IItemContainerMapping {
    constructor();

    itemFromContainer(container: Object): Object;

    containerFromItem(item: Object): Object;

    indexFromContainer(container: Object): Number;

    containerFromIndex(index: Number): Object;

  }

  export class INavigate {
    constructor();

    navigate(sourcePageType: Object): Boolean;

  }

  export class ISemanticZoomInformation {
    isActiveView: Boolean;
    isZoomedInView: Boolean;
    semanticZoomOwner: SemanticZoom;
    constructor();

    initializeViewChange(): void;

    completeViewChange(): void;

    makeVisible(item: SemanticZoomLocation): void;

    startViewChangeFrom(source: SemanticZoomLocation, destination: SemanticZoomLocation): void;

    startViewChangeTo(source: SemanticZoomLocation, destination: SemanticZoomLocation): void;

    completeViewChangeFrom(source: SemanticZoomLocation, destination: SemanticZoomLocation): void;

    completeViewChangeTo(source: SemanticZoomLocation, destination: SemanticZoomLocation): void;

  }

  export class SemanticZoomLocation {
    item: Object;
    bounds: Object;
    constructor();

  }

  export class CandidateWindowBoundsChangedEventArgs {
    bounds: Object;
    constructor();

  }

  export class ChoosingGroupHeaderContainerEventArgs {
    groupHeaderContainer: ListViewBaseHeaderItem;
    group: Object;
    groupIndex: Number;
    constructor();

  }

  export class ChoosingItemContainerEventArgs {
    itemContainer: Object;
    isContainerPrepared: Boolean;
    item: Object;
    itemIndex: Number;
    constructor();

  }

  export class ColumnDefinitionCollection {
    constructor();

    getAt(index: Number): ColumnDefinition;

    getView(): Object;

    indexOf(value: ColumnDefinition, index: Number): Boolean;

    setAt(index: Number, value: ColumnDefinition): void;

    insertAt(index: Number, value: ColumnDefinition): void;

    removeAt(index: Number): void;

    append(value: ColumnDefinition): void;

    removeAtEnd(): void;

    clear(): void;

    getMany();
    replaceAll(items: Array<Object>): void;

    first(): Object;

  }

  export class DataTemplateSelector {
    constructor();

    selectTemplate(item: Object, container: Object): Object;
    selectTemplate(item: Object): Object;

    selectTemplateCore(item: Object, container: Object): Object;
    selectTemplateCore(item: Object): Object;

  }

  export class DragItemsCompletedEventArgs {
    dropResult: Number;
    items: Object;
    constructor();

  }

  export class StyleSelector {
    constructor();

    selectStyle(item: Object, container: Object): Object;

    selectStyleCore(item: Object, container: Object): Object;

  }

  export class GroupStyle {
    panel: ItemsPanelTemplate;
    hidesIfEmpty: Boolean;
    headerTemplateSelector: DataTemplateSelector;
    headerTemplate: Object;
    containerStyleSelector: StyleSelector;
    containerStyle: Object;
    headerContainerStyle: Object;
    constructor();

  }

  export class GroupStyleSelector {
    constructor();

    selectGroupStyle(group: Object, level: Number): GroupStyle;

    selectGroupStyleCore(group: Object, level: Number): GroupStyle;

  }

  export class HandwritingPanelClosedEventArgs {
    constructor();

  }

  export class HandwritingPanelOpenedEventArgs {
    constructor();

  }

  export class IsTextTrimmedChangedEventArgs {
    constructor();

  }

  export class ItemCollection {
    constructor();

    getAt(index: Number): Object;

    getView(): Object;

    indexOf(value: Object, index: Number): Boolean;

    setAt(index: Number, value: Object): void;

    insertAt(index: Number, value: Object): void;

    removeAt(index: Number): void;

    append(value: Object): void;

    removeAtEnd(): void;

    clear(): void;

    getMany();
    replaceAll(items: Array<Object>): void;

    first(): Object;

    addListener(type: "VectorChanged", listener: (ev: Event) => void): void ;
    removeListener(type: "VectorChanged", listener: (ev: Event) => void): void ;
    on(type: "VectorChanged", listener: (ev: Event) => void): void ;
    off(type: "VectorChanged", listener: (ev: Event) => void): void ;
    
    addListener(type: string, listener: (ev: Event) => void): void ;
    removeListener(type: string, listener: (ev: Event) => void): void ;
    on(type: string, listener: (ev: Event) => void): void ;
    off(type: string, listener: (ev: Event) => void): void ;
    

  }

  export class ItemContainerGenerator {
    constructor();

    itemFromContainer(container: Object): Object;

    containerFromItem(item: Object): Object;

    indexFromContainer(container: Object): Number;

    containerFromIndex(index: Number): Object;

    getItemContainerGeneratorForPanel(panel: Panel): ItemContainerGenerator;

    startAt(position: GeneratorPosition, direction: Number, allowStartAtRealizedItem: Boolean): void;

    stop(): void;

    generateNext(isNewlyRealized: Boolean): Object;

    prepareItemContainer(container: Object): void;

    removeAll(): void;

    remove(position: GeneratorPosition, count: Number): void;

    generatorPositionFromIndex(itemIndex: Number): GeneratorPosition;

    indexFromGeneratorPosition(position: GeneratorPosition): Number;

    recycle(position: GeneratorPosition, count: Number): void;

    addListener(type: "ItemsChanged", listener: (ev: Event) => void): void ;
    removeListener(type: "ItemsChanged", listener: (ev: Event) => void): void ;
    on(type: "ItemsChanged", listener: (ev: Event) => void): void ;
    off(type: "ItemsChanged", listener: (ev: Event) => void): void ;
    
    addListener(type: string, listener: (ev: Event) => void): void ;
    removeListener(type: string, listener: (ev: Event) => void): void ;
    on(type: string, listener: (ev: Event) => void): void ;
    off(type: string, listener: (ev: Event) => void): void ;
    

  }

  export class MediaTransportControlsHelper {
    static dropoutOrderProperty: Object;
    constructor();

    static getDropoutOrder(element: Object): Number;


    static setDropoutOrder(element: Object, value: Number): void;


  }

  export class PasswordBoxPasswordChangingEventArgs {
    isContentChanging: Boolean;
    constructor();

  }

  export class RowDefinitionCollection {
    constructor();

    getAt(index: Number): RowDefinition;

    getView(): Object;

    indexOf(value: RowDefinition, index: Number): Boolean;

    setAt(index: Number, value: RowDefinition): void;

    insertAt(index: Number, value: RowDefinition): void;

    removeAt(index: Number): void;

    append(value: RowDefinition): void;

    removeAtEnd(): void;

    clear(): void;

    getMany();
    replaceAll(items: Array<Object>): void;

    first(): Object;

  }

  export class TextBoxBeforeTextChangingEventArgs {
    cancel: Boolean;
    newText: String;
    constructor();

  }

  export class TextBoxTextChangingEventArgs {
    isContentChanging: Boolean;
    constructor();

  }

  export class TextCompositionChangedEventArgs {
    length: Number;
    startIndex: Number;
    constructor();

  }

  export class TextCompositionEndedEventArgs {
    length: Number;
    startIndex: Number;
    constructor();

  }

  export class TextCompositionStartedEventArgs {
    length: Number;
    startIndex: Number;
    constructor();

  }

  export class TextControlCopyingToClipboardEventArgs {
    handled: Boolean;
    constructor();

  }

  export class TextControlCuttingToClipboardEventArgs {
    handled: Boolean;
    constructor();

  }

  export class ToolTipService {
    static placementProperty: Object;
    static placementTargetProperty: Object;
    static toolTipProperty: Object;
    constructor();

    static getPlacement(element: Object): Number;


    static setPlacement(element: Object, value: Number): void;


    static getPlacementTarget(element: Object): Object;


    static setPlacementTarget(element: Object, value: Object): void;


    static getToolTip(element: Object): Object;


    static setToolTip(element: Object, value: Object): void;


  }

  export class CalendarViewDayItemChangingEventArgs {
    inRecycleQueue: Boolean;
    item: CalendarViewDayItem;
    phase: Number;
    constructor();

    registerUpdateCallback(callback: Object): void;
    registerUpdateCallback(callbackPhase: Number, callback: Object): void;

  }

  export class HubSectionHeaderClickEventArgs {
    section: HubSection;
    constructor();

  }

  export class SectionsInViewChangedEventArgs {
    addedSections: Object;
    removedSections: Object;
    constructor();

  }

  export class WebViewNavigationFailedEventArgs {
    uri: Object;
    webErrorStatus: Number;
    constructor();

  }

  export class ICommandBarElement {
    isCompact: Boolean;
    constructor();

  }

  export class ICommandBarElement2 {
    dynamicOverflowOrder: Number;
    isInOverflow: Boolean;
    constructor();

  }

  export class CalendarDatePickerDateChangedEventArgs {
    newDate: Date;
    oldDate: Date;
    constructor();

  }

  export class CalendarViewSelectedDatesChangedEventArgs {
    addedDates: Object;
    removedDates: Object;
    constructor();

  }

  export class ContentDialogButtonClickDeferral {
    constructor();

    complete(): void;

  }

  export class ContentDialogButtonClickEventArgs {
    cancel: Boolean;
    constructor();

    getDeferral(): ContentDialogButtonClickDeferral;

  }

  export class ContentDialogClosedEventArgs {
    result: ContentDialogResult;
    constructor();

  }

  export class ContentDialogClosingDeferral {
    constructor();

    complete(): void;

  }

  export class ContentDialogClosingEventArgs {
    cancel: Boolean;
    result: ContentDialogResult;
    constructor();

    getDeferral(): ContentDialogClosingDeferral;

  }

  export class ContentDialogOpenedEventArgs {
    constructor();

  }

  export class ContentLinkChangedEventArgs {
    changeKind: ContentLinkChangeKind;
    contentLinkInfo: Object;
    textRange: TextRange;
    constructor();

  }

  export class DatePickerValueChangedEventArgs {
    newDate: Date;
    oldDate: Date;
    constructor();

  }

  export class DynamicOverflowItemsChangingEventArgs {
    action: CommandBarDynamicOverflowAction;
    constructor();

  }

  export class HubSectionCollection {
    constructor();

    getAt(index: Number): HubSection;

    getView(): Object;

    indexOf(value: HubSection, index: Number): Boolean;

    setAt(index: Number, value: HubSection): void;

    insertAt(index: Number, value: HubSection): void;

    removeAt(index: Number): void;

    append(value: HubSection): void;

    removeAtEnd(): void;

    clear(): void;

    getMany();
    replaceAll(items: Array<Object>): void;

    first(): Object;

  }

  export class ListViewPersistenceHelper {
    constructor();

    static setRelativeScrollPositionAsync(listViewBase: ListViewBase, relativeScrollPosition: String, keyToItemHandler: Object, callback: (error: Error) => void): void ;


    static getRelativeScrollPosition(listViewBase: ListViewBase, itemToKeyHandler: Object): String;


  }

  export class RichEditBoxTextChangingEventArgs {
    isContentChanging: Boolean;
    constructor();

  }

  export class ScrollViewerView {
    horizontalOffset: Number;
    verticalOffset: Number;
    zoomFactor: Number;
    constructor();

  }

  export class ScrollViewerViewChangedEventArgs {
    isIntermediate: Boolean;
    constructor();

  }

  export class ScrollViewerViewChangingEventArgs {
    finalView: ScrollViewerView;
    isInertial: Boolean;
    nextView: ScrollViewerView;
    constructor();

  }

  export class SearchBoxQueryChangedEventArgs {
    language: String;
    linguisticDetails: Object;
    queryText: String;
    constructor();

  }

  export class SearchBoxQuerySubmittedEventArgs {
    keyModifiers: Number;
    language: String;
    linguisticDetails: Object;
    queryText: String;
    constructor();

  }

  export class SearchBoxResultSuggestionChosenEventArgs {
    keyModifiers: Number;
    tag: String;
    constructor();

  }

  export class SearchBoxSuggestionsRequestedEventArgs {
    language: String;
    linguisticDetails: Object;
    queryText: String;
    request: Object;
    constructor();

  }

  export class SplitViewPaneClosingEventArgs {
    cancel: Boolean;
    constructor();

  }

  export class TimePickerValueChangedEventArgs {
    newTime: Number;
    oldTime: Number;
    constructor();

  }

  export class WebViewContentLoadingEventArgs {
    uri: Object;
    constructor();

  }

  export class WebViewDeferredPermissionRequest {
    id: Number;
    permissionType: WebViewPermissionType;
    uri: Object;
    constructor();

    allow(): void;

    deny(): void;

  }

  export class WebViewDOMContentLoadedEventArgs {
    uri: Object;
    constructor();

  }

  export class WebViewLongRunningScriptDetectedEventArgs {
    stopPageScriptExecution: Boolean;
    executionTime: Number;
    constructor();

  }

  export class WebViewNavigationCompletedEventArgs {
    isSuccess: Boolean;
    uri: Object;
    webErrorStatus: Number;
    constructor();

  }

  export class WebViewNavigationStartingEventArgs {
    cancel: Boolean;
    uri: Object;
    constructor();

  }

  export class WebViewNewWindowRequestedEventArgs {
    handled: Boolean;
    referrer: Object;
    uri: Object;
    constructor();

  }

  export class WebViewPermissionRequest {
    id: Number;
    permissionType: WebViewPermissionType;
    state: WebViewPermissionState;
    uri: Object;
    constructor();

    defer(): void;

    allow(): void;

    deny(): void;

  }

  export class WebViewPermissionRequestedEventArgs {
    permissionRequest: WebViewPermissionRequest;
    constructor();

  }

  export class WebViewSeparateProcessLostEventArgs {
    constructor();

  }

  export class WebViewSettings {
    isJavaScriptEnabled: Boolean;
    isIndexedDBEnabled: Boolean;
    constructor();

  }

  export class WebViewUnsupportedUriSchemeIdentifiedEventArgs {
    handled: Boolean;
    uri: Object;
    constructor();

  }

  export class WebViewUnviewableContentIdentifiedEventArgs {
    referrer: Object;
    uri: Object;
    mediaType: String;
    constructor();

  }

  export class RatingItemInfo {
    dispatcher: Object;
    constructor();

  }

  export class RatingItemFontInfo {
    static disabledGlyphProperty: Object;
    static glyphProperty: Object;
    static placeholderGlyphProperty: Object;
    static pointerOverGlyphProperty: Object;
    static pointerOverPlaceholderGlyphProperty: Object;
    static unsetGlyphProperty: Object;
    unsetGlyph: String;
    pointerOverPlaceholderGlyph: String;
    pointerOverGlyph: String;
    placeholderGlyph: String;
    glyph: String;
    disabledGlyph: String;
    dispatcher: Object;
    constructor();

  }

  export class RatingItemImageInfo {
    static disabledImageProperty: Object;
    static imageProperty: Object;
    static placeholderImageProperty: Object;
    static pointerOverImageProperty: Object;
    static pointerOverPlaceholderImageProperty: Object;
    static unsetImageProperty: Object;
    unsetImage: Object;
    pointerOverPlaceholderImage: Object;
    pointerOverImage: Object;
    placeholderImage: Object;
    image: Object;
    disabledImage: Object;
    dispatcher: Object;
    constructor();

  }

  export class SwipeItem {
    static backgroundProperty: Object;
    static behaviorOnInvokedProperty: Object;
    static commandParameterProperty: Object;
    static commandProperty: Object;
    static foregroundProperty: Object;
    static iconSourceProperty: Object;
    static textProperty: Object;
    text: String;
    iconSource: IconSource;
    foreground: Object;
    commandParameter: Object;
    command: Object;
    behaviorOnInvoked: SwipeBehaviorOnInvoked;
    background: Object;
    dispatcher: Object;
    constructor();

    addListener(type: "Invoked", listener: (ev: Event) => void): void ;
    removeListener(type: "Invoked", listener: (ev: Event) => void): void ;
    on(type: "Invoked", listener: (ev: Event) => void): void ;
    off(type: "Invoked", listener: (ev: Event) => void): void ;
    
    addListener(type: string, listener: (ev: Event) => void): void ;
    removeListener(type: string, listener: (ev: Event) => void): void ;
    on(type: string, listener: (ev: Event) => void): void ;
    off(type: string, listener: (ev: Event) => void): void ;
    

  }

  export class SwipeItems {
    static modeProperty: Object;
    mode: SwipeMode;
    dispatcher: Object;
    constructor();

    getAt(index: Number): SwipeItem;

    getView(): Object;

    indexOf(value: SwipeItem, index: Number): Boolean;

    setAt(index: Number, value: SwipeItem): void;

    insertAt(index: Number, value: SwipeItem): void;

    removeAt(index: Number): void;

    append(value: SwipeItem): void;

    removeAtEnd(): void;

    clear(): void;

    getMany();
    replaceAll(items: Array<Object>): void;

    first(): Object;

  }

  export class TreeViewNode {
    static contentProperty: Object;
    static depthProperty: Object;
    static hasChildrenProperty: Object;
    static isExpandedProperty: Object;
    isExpanded: Boolean;
    hasUnrealizedChildren: Boolean;
    content: Object;
    children: Object;
    depth: Number;
    hasChildren: Boolean;
    parent: TreeViewNode;
    dispatcher: Object;
    constructor();

  }

  export class TreeViewItemTemplateSettings {
    static collapsedGlyphVisibilityProperty: Object;
    static dragItemsCountProperty: Object;
    static expandedGlyphVisibilityProperty: Object;
    static indentationProperty: Object;
    collapsedGlyphVisibility: Number;
    dragItemsCount: Number;
    expandedGlyphVisibility: Number;
    indentation: Thickness;
    dispatcher: Object;
    constructor();

  }

  export class ColumnDefinition {
    static maxWidthProperty: Object;
    static minWidthProperty: Object;
    static widthProperty: Object;
    width: GridLength;
    minWidth: Number;
    maxWidth: Number;
    actualWidth: Number;
    dispatcher: Object;
    constructor();

  }

  export class RowDefinition {
    static heightProperty: Object;
    static maxHeightProperty: Object;
    static minHeightProperty: Object;
    minHeight: Number;
    maxHeight: Number;
    height: GridLength;
    actualHeight: Number;
    dispatcher: Object;
    constructor();

  }

  export class IconSource {
    static foregroundProperty: Object;
    foreground: Object;
    dispatcher: Object;
    constructor();

  }

  export class AutoSuggestBoxQuerySubmittedEventArgs {
    chosenSuggestion: Object;
    queryText: String;
    dispatcher: Object;
    constructor();

  }

  export class AutoSuggestBoxSuggestionChosenEventArgs {
    selectedItem: Object;
    dispatcher: Object;
    constructor();

  }

  export class AutoSuggestBoxTextChangedEventArgs {
    static reasonProperty: Object;
    reason: AutoSuggestionBoxTextChangeReason;
    dispatcher: Object;
    constructor();

    checkCurrent(): Boolean;

  }

  export class BitmapIconSource {
    static showAsMonochromeProperty: Object;
    static uriSourceProperty: Object;
    static foregroundProperty: Object;
    uriSource: Object;
    showAsMonochrome: Boolean;
    foreground: Object;
    dispatcher: Object;
    constructor();

  }

  export class FontIconSource {
    static fontFamilyProperty: Object;
    static fontSizeProperty: Object;
    static fontStyleProperty: Object;
    static fontWeightProperty: Object;
    static glyphProperty: Object;
    static isTextScaleFactorEnabledProperty: Object;
    static mirroredWhenRightToLeftProperty: Object;
    static foregroundProperty: Object;
    mirroredWhenRightToLeft: Boolean;
    isTextScaleFactorEnabled: Boolean;
    glyph: String;
    fontWeight: FontWeight;
    fontStyle: Number;
    fontSize: Number;
    fontFamily: Object;
    foreground: Object;
    dispatcher: Object;
    constructor();

  }

  export class PathIconSource {
    static dataProperty: Object;
    static foregroundProperty: Object;
    data: Object;
    foreground: Object;
    dispatcher: Object;
    constructor();

  }

  export class SymbolIconSource {
    static symbolProperty: Object;
    static foregroundProperty: Object;
    symbol: Symbol;
    foreground: Object;
    dispatcher: Object;
    constructor();

  }

  export class CleanUpVirtualizedItemEventArgs {
    cancel: Boolean;
    uIElement: Object;
    value: Object;
    originalSource: Object;
    constructor();

  }

  export class ContextMenuEventArgs {
    handled: Boolean;
    cursorLeft: Number;
    cursorTop: Number;
    originalSource: Object;
    constructor();

  }

  export class ItemClickEventArgs {
    clickedItem: Object;
    originalSource: Object;
    constructor();

  }

  export class SelectionChangedEventArgs {
    addedItems: Object;
    removedItems: Object;
    originalSource: Object;
    constructor();
    constructor(removedItems: Object, addedItems: Object);

  }

  export class TextChangedEventArgs {
    originalSource: Object;
    constructor();

  }

  export class ItemsPanelTemplate {
    dispatcher: Object;
    constructor();

  }

  export class ParallaxView {
    static childProperty: Object;
    static horizontalShiftProperty: Object;
    static horizontalSourceEndOffsetProperty: Object;
    static horizontalSourceOffsetKindProperty: Object;
    static horizontalSourceStartOffsetProperty: Object;
    static isHorizontalShiftClampedProperty: Object;
    static isVerticalShiftClampedProperty: Object;
    static maxHorizontalShiftRatioProperty: Object;
    static maxVerticalShiftRatioProperty: Object;
    static sourceProperty: Object;
    static verticalShiftProperty: Object;
    static verticalSourceEndOffsetProperty: Object;
    static verticalSourceOffsetKindProperty: Object;
    static verticalSourceStartOffsetProperty: Object;
    static actualHeightProperty: Object;
    static actualWidthProperty: Object;
    static dataContextProperty: Object;
    static flowDirectionProperty: Object;
    static heightProperty: Object;
    static horizontalAlignmentProperty: Object;
    static languageProperty: Object;
    static maxHeightProperty: Object;
    static maxWidthProperty: Object;
    static minHeightProperty: Object;
    static minWidthProperty: Object;
    static nameProperty: Object;
    static styleProperty: Object;
    static tagProperty: Object;
    static verticalAlignmentProperty: Object;
    static widthProperty: Object;
    static marginProperty: Object;
    static requestedThemeProperty: Object;
    static allowFocusOnInteractionProperty: Object;
    static focusVisualMarginProperty: Object;
    static focusVisualPrimaryBrushProperty: Object;
    static focusVisualPrimaryThicknessProperty: Object;
    static focusVisualSecondaryBrushProperty: Object;
    static focusVisualSecondaryThicknessProperty: Object;
    static allowFocusWhenDisabledProperty: Object;
    static actualThemeProperty: Object;
    static allowDropProperty: Object;
    static cacheModeProperty: Object;
    static clipProperty: Object;
    static doubleTappedEvent: Object;
    static dragEnterEvent: Object;
    static dragLeaveEvent: Object;
    static dragOverEvent: Object;
    static dropEvent: Object;
    static holdingEvent: Object;
    static isDoubleTapEnabledProperty: Object;
    static isHitTestVisibleProperty: Object;
    static isHoldingEnabledProperty: Object;
    static isRightTapEnabledProperty: Object;
    static isTapEnabledProperty: Object;
    static keyUpEvent: Object;
    static manipulationCompletedEvent: Object;
    static manipulationDeltaEvent: Object;
    static manipulationInertiaStartingEvent: Object;
    static manipulationModeProperty: Object;
    static manipulationStartedEvent: Object;
    static manipulationStartingEvent: Object;
    static opacityProperty: Object;
    static pointerCanceledEvent: Object;
    static pointerCaptureLostEvent: Object;
    static pointerCapturesProperty: Object;
    static pointerEnteredEvent: Object;
    static pointerExitedEvent: Object;
    static pointerMovedEvent: Object;
    static pointerPressedEvent: Object;
    static pointerReleasedEvent: Object;
    static pointerWheelChangedEvent: Object;
    static projectionProperty: Object;
    static renderTransformOriginProperty: Object;
    static renderTransformProperty: Object;
    static rightTappedEvent: Object;
    static tappedEvent: Object;
    static transitionsProperty: Object;
    static useLayoutRoundingProperty: Object;
    static visibilityProperty: Object;
    static keyDownEvent: Object;
    static compositeModeProperty: Object;
    static transform3DProperty: Object;
    static canDragProperty: Object;
    static isAccessKeyScopeProperty: Object;
    static exitDisplayModeOnAccessKeyInvokedProperty: Object;
    static contextFlyoutProperty: Object;
    static accessKeyScopeOwnerProperty: Object;
    static accessKeyProperty: Object;
    static highContrastAdjustmentProperty: Object;
    static xYFocusRightNavigationStrategyProperty: Object;
    static xYFocusUpNavigationStrategyProperty: Object;
    static keyTipHorizontalOffsetProperty: Object;
    static keyTipPlacementModeProperty: Object;
    static keyTipVerticalOffsetProperty: Object;
    static lightsProperty: Object;
    static tabFocusNavigationProperty: Object;
    static xYFocusDownNavigationStrategyProperty: Object;
    static xYFocusKeyboardNavigationProperty: Object;
    static xYFocusLeftNavigationStrategyProperty: Object;
    static noFocusCandidateFoundEvent: Object;
    static losingFocusEvent: Object;
    static gettingFocusEvent: Object;
    static previewKeyUpEvent: Object;
    static previewKeyDownEvent: Object;
    static characterReceivedEvent: Object;
    static keyboardAcceleratorPlacementTargetProperty: Object;
    static keyboardAcceleratorPlacementModeProperty: Object;
    static keyTipTargetProperty: Object;
    static contextRequestedEvent: Object;
    static bringIntoViewRequestedEvent: Object;
    verticalSourceStartOffset: Number;
    verticalSourceOffsetKind: ParallaxSourceOffsetKind;
    verticalSourceEndOffset: Number;
    verticalShift: Number;
    source: Object;
    maxVerticalShiftRatio: Number;
    maxHorizontalShiftRatio: Number;
    isVerticalShiftClamped: Boolean;
    isHorizontalShiftClamped: Boolean;
    horizontalSourceStartOffset: Number;
    horizontalSourceOffsetKind: ParallaxSourceOffsetKind;
    horizontalSourceEndOffset: Number;
    horizontalShift: Number;
    child: Object;
    flowDirection: Number;
    minWidth: Number;
    minHeight: Number;
    maxWidth: Number;
    maxHeight: Number;
    margin: Thickness;
    language: String;
    name: String;
    horizontalAlignment: Number;
    height: Number;
    dataContext: Object;
    resources: Object;
    width: Number;
    tag: Object;
    style: Object;
    verticalAlignment: Number;
    actualHeight: Number;
    actualWidth: Number;
    parent: Object;
    baseUri: Object;
    triggers: Object;
    requestedTheme: Number;
    focusVisualSecondaryThickness: Thickness;
    focusVisualSecondaryBrush: Object;
    focusVisualPrimaryThickness: Thickness;
    focusVisualPrimaryBrush: Object;
    focusVisualMargin: Thickness;
    allowFocusWhenDisabled: Boolean;
    allowFocusOnInteraction: Boolean;
    actualTheme: Number;
    manipulationMode: Number;
    isTapEnabled: Boolean;
    isRightTapEnabled: Boolean;
    isHoldingEnabled: Boolean;
    isHitTestVisible: Boolean;
    isDoubleTapEnabled: Boolean;
    opacity: Number;
    cacheMode: Object;
    allowDrop: Boolean;
    clip: Object;
    visibility: Number;
    useLayoutRounding: Boolean;
    renderTransformOrigin: Object;
    projection: Object;
    renderTransform: Object;
    transitions: Object;
    renderSize: Object;
    pointerCaptures: Object;
    desiredSize: Object;
    compositeMode: Number;
    transform3D: Object;
    canDrag: Boolean;
    accessKey: String;
    accessKeyScopeOwner: Object;
    exitDisplayModeOnAccessKeyInvoked: Boolean;
    contextFlyout: Object;
    isAccessKeyScope: Boolean;
    xYFocusDownNavigationStrategy: Number;
    xYFocusLeftNavigationStrategy: Number;
    tabFocusNavigation: Number;
    xYFocusKeyboardNavigation: Number;
    keyTipVerticalOffset: Number;
    keyTipPlacementMode: Number;
    keyTipHorizontalOffset: Number;
    highContrastAdjustment: Number;
    xYFocusUpNavigationStrategy: Number;
    xYFocusRightNavigationStrategy: Number;
    lights: Object;
    keyboardAccelerators: Object;
    keyboardAcceleratorPlacementTarget: Object;
    keyboardAcceleratorPlacementMode: Number;
    keyTipTarget: Object;
    dispatcher: Object;
    constructor();

    refreshAutomaticHorizontalOffsets(): void;

    refreshAutomaticVerticalOffsets(): void;

    addListener(type: "LayoutUpdated", listener: (ev: Event) => void): void ;
    removeListener(type: "LayoutUpdated", listener: (ev: Event) => void): void ;
    on(type: "LayoutUpdated", listener: (ev: Event) => void): void ;
    off(type: "LayoutUpdated", listener: (ev: Event) => void): void ;
    
    addListener(type: "Loaded", listener: (ev: Event) => void): void ;
    removeListener(type: "Loaded", listener: (ev: Event) => void): void ;
    on(type: "Loaded", listener: (ev: Event) => void): void ;
    off(type: "Loaded", listener: (ev: Event) => void): void ;
    
    addListener(type: "SizeChanged", listener: (ev: Event) => void): void ;
    removeListener(type: "SizeChanged", listener: (ev: Event) => void): void ;
    on(type: "SizeChanged", listener: (ev: Event) => void): void ;
    off(type: "SizeChanged", listener: (ev: Event) => void): void ;
    
    addListener(type: "Unloaded", listener: (ev: Event) => void): void ;
    removeListener(type: "Unloaded", listener: (ev: Event) => void): void ;
    on(type: "Unloaded", listener: (ev: Event) => void): void ;
    off(type: "Unloaded", listener: (ev: Event) => void): void ;
    
    addListener(type: "DataContextChanged", listener: (ev: Event) => void): void ;
    removeListener(type: "DataContextChanged", listener: (ev: Event) => void): void ;
    on(type: "DataContextChanged", listener: (ev: Event) => void): void ;
    off(type: "DataContextChanged", listener: (ev: Event) => void): void ;
    
    addListener(type: "Loading", listener: (ev: Event) => void): void ;
    removeListener(type: "Loading", listener: (ev: Event) => void): void ;
    on(type: "Loading", listener: (ev: Event) => void): void ;
    off(type: "Loading", listener: (ev: Event) => void): void ;
    
    addListener(type: "ActualThemeChanged", listener: (ev: Event) => void): void ;
    removeListener(type: "ActualThemeChanged", listener: (ev: Event) => void): void ;
    on(type: "ActualThemeChanged", listener: (ev: Event) => void): void ;
    off(type: "ActualThemeChanged", listener: (ev: Event) => void): void ;
    
    addListener(type: "DoubleTapped", listener: (ev: Event) => void): void ;
    removeListener(type: "DoubleTapped", listener: (ev: Event) => void): void ;
    on(type: "DoubleTapped", listener: (ev: Event) => void): void ;
    off(type: "DoubleTapped", listener: (ev: Event) => void): void ;
    
    addListener(type: "DragEnter", listener: (ev: Event) => void): void ;
    removeListener(type: "DragEnter", listener: (ev: Event) => void): void ;
    on(type: "DragEnter", listener: (ev: Event) => void): void ;
    off(type: "DragEnter", listener: (ev: Event) => void): void ;
    
    addListener(type: "DragLeave", listener: (ev: Event) => void): void ;
    removeListener(type: "DragLeave", listener: (ev: Event) => void): void ;
    on(type: "DragLeave", listener: (ev: Event) => void): void ;
    off(type: "DragLeave", listener: (ev: Event) => void): void ;
    
    addListener(type: "DragOver", listener: (ev: Event) => void): void ;
    removeListener(type: "DragOver", listener: (ev: Event) => void): void ;
    on(type: "DragOver", listener: (ev: Event) => void): void ;
    off(type: "DragOver", listener: (ev: Event) => void): void ;
    
    addListener(type: "Drop", listener: (ev: Event) => void): void ;
    removeListener(type: "Drop", listener: (ev: Event) => void): void ;
    on(type: "Drop", listener: (ev: Event) => void): void ;
    off(type: "Drop", listener: (ev: Event) => void): void ;
    
    addListener(type: "GotFocus", listener: (ev: Event) => void): void ;
    removeListener(type: "GotFocus", listener: (ev: Event) => void): void ;
    on(type: "GotFocus", listener: (ev: Event) => void): void ;
    off(type: "GotFocus", listener: (ev: Event) => void): void ;
    
    addListener(type: "Holding", listener: (ev: Event) => void): void ;
    removeListener(type: "Holding", listener: (ev: Event) => void): void ;
    on(type: "Holding", listener: (ev: Event) => void): void ;
    off(type: "Holding", listener: (ev: Event) => void): void ;
    
    addListener(type: "KeyDown", listener: (ev: Event) => void): void ;
    removeListener(type: "KeyDown", listener: (ev: Event) => void): void ;
    on(type: "KeyDown", listener: (ev: Event) => void): void ;
    off(type: "KeyDown", listener: (ev: Event) => void): void ;
    
    addListener(type: "KeyUp", listener: (ev: Event) => void): void ;
    removeListener(type: "KeyUp", listener: (ev: Event) => void): void ;
    on(type: "KeyUp", listener: (ev: Event) => void): void ;
    off(type: "KeyUp", listener: (ev: Event) => void): void ;
    
    addListener(type: "LostFocus", listener: (ev: Event) => void): void ;
    removeListener(type: "LostFocus", listener: (ev: Event) => void): void ;
    on(type: "LostFocus", listener: (ev: Event) => void): void ;
    off(type: "LostFocus", listener: (ev: Event) => void): void ;
    
    addListener(type: "ManipulationCompleted", listener: (ev: Event) => void): void ;
    removeListener(type: "ManipulationCompleted", listener: (ev: Event) => void): void ;
    on(type: "ManipulationCompleted", listener: (ev: Event) => void): void ;
    off(type: "ManipulationCompleted", listener: (ev: Event) => void): void ;
    
    addListener(type: "ManipulationDelta", listener: (ev: Event) => void): void ;
    removeListener(type: "ManipulationDelta", listener: (ev: Event) => void): void ;
    on(type: "ManipulationDelta", listener: (ev: Event) => void): void ;
    off(type: "ManipulationDelta", listener: (ev: Event) => void): void ;
    
    addListener(type: "ManipulationInertiaStarting", listener: (ev: Event) => void): void ;
    removeListener(type: "ManipulationInertiaStarting", listener: (ev: Event) => void): void ;
    on(type: "ManipulationInertiaStarting", listener: (ev: Event) => void): void ;
    off(type: "ManipulationInertiaStarting", listener: (ev: Event) => void): void ;
    
    addListener(type: "ManipulationStarted", listener: (ev: Event) => void): void ;
    removeListener(type: "ManipulationStarted", listener: (ev: Event) => void): void ;
    on(type: "ManipulationStarted", listener: (ev: Event) => void): void ;
    off(type: "ManipulationStarted", listener: (ev: Event) => void): void ;
    
    addListener(type: "ManipulationStarting", listener: (ev: Event) => void): void ;
    removeListener(type: "ManipulationStarting", listener: (ev: Event) => void): void ;
    on(type: "ManipulationStarting", listener: (ev: Event) => void): void ;
    off(type: "ManipulationStarting", listener: (ev: Event) => void): void ;
    
    addListener(type: "PointerCanceled", listener: (ev: Event) => void): void ;
    removeListener(type: "PointerCanceled", listener: (ev: Event) => void): void ;
    on(type: "PointerCanceled", listener: (ev: Event) => void): void ;
    off(type: "PointerCanceled", listener: (ev: Event) => void): void ;
    
    addListener(type: "PointerCaptureLost", listener: (ev: Event) => void): void ;
    removeListener(type: "PointerCaptureLost", listener: (ev: Event) => void): void ;
    on(type: "PointerCaptureLost", listener: (ev: Event) => void): void ;
    off(type: "PointerCaptureLost", listener: (ev: Event) => void): void ;
    
    addListener(type: "PointerEntered", listener: (ev: Event) => void): void ;
    removeListener(type: "PointerEntered", listener: (ev: Event) => void): void ;
    on(type: "PointerEntered", listener: (ev: Event) => void): void ;
    off(type: "PointerEntered", listener: (ev: Event) => void): void ;
    
    addListener(type: "PointerExited", listener: (ev: Event) => void): void ;
    removeListener(type: "PointerExited", listener: (ev: Event) => void): void ;
    on(type: "PointerEx