// Copyright (c) The NodeRT Contributors
// All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the ""License""); you may
// not use this file except in compliance with the License. You may obtain a
// copy of the License at http://www.apache.org/licenses/LICENSE-2.0
//
// THIS CODE IS PROVIDED ON AN  *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS
// OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY
// IMPLIED WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
// MERCHANTABLITY OR NON-INFRINGEMENT.
//
// See the Apache Version 2.0 License for specific language governing permissions
// and limitations under the License.

// TODO: Verify that this is is still needed..
#define NTDDI_VERSION 0x06010000

#include <v8.h>
#include "nan.h"
#include <string>
#include <ppltasks.h>
#include "CollectionsConverter.h"
#include "CollectionsWrap.h"
#include "node-async.h"
#include "NodeRtUtils.h"
#include "OpaqueWrapper.h"
#include "WrapperBase.h"

#using <Windows.WinMD>

// this undefs fixes the issues of compiling Windows.Data.Json, Windows.Storag.FileProperties, and Windows.Stroage.Search
// Some of the node header files brings windows definitions with the same names as some of the WinRT methods
#undef DocumentProperties
#undef GetObject
#undef CreateEvent
#undef FindText
#undef SendMessage

const char* REGISTRATION_TOKEN_MAP_PROPERTY_NAME = "__registrationTokenMap__";

using v8::Array;
using v8::String;
using v8::Value;
using v8::Boolean;
using v8::Integer;
using v8::FunctionTemplate;
using v8::Object;
using v8::Local;
using v8::Function;
using v8::Date;
using v8::Number;
using v8::PropertyAttribute;
using v8::Primitive;
using Nan::HandleScope;
using Nan::Persistent;
using Nan::Undefined;
using Nan::True;
using Nan::False;
using Nan::Null;
using Nan::MaybeLocal;
using Nan::EscapableHandleScope;
using Nan::HandleScope;
using Nan::TryCatch;
using namespace concurrency;

namespace NodeRT { namespace Windows { namespace UI { namespace Xaml { 
  v8::Local<v8::Value> WrapDependencyObject(::Windows::UI::Xaml::DependencyObject^ wintRtInstance);
  ::Windows::UI::Xaml::DependencyObject^ UnwrapDependencyObject(Local<Value> value);
  
  v8::Local<v8::Value> WrapStateTriggerBase(::Windows::UI::Xaml::StateTriggerBase^ wintRtInstance);
  ::Windows::UI::Xaml::StateTriggerBase^ UnwrapStateTriggerBase(Local<Value> value);
  
  v8::Local<v8::Value> WrapAdaptiveTrigger(::Windows::UI::Xaml::AdaptiveTrigger^ wintRtInstance);
  ::Windows::UI::Xaml::AdaptiveTrigger^ UnwrapAdaptiveTrigger(Local<Value> value);
  
  v8::Local<v8::Value> WrapApplication(::Windows::UI::Xaml::Application^ wintRtInstance);
  ::Windows::UI::Xaml::Application^ UnwrapApplication(Local<Value> value);
  
  v8::Local<v8::Value> WrapApplicationInitializationCallbackParams(::Windows::UI::Xaml::ApplicationInitializationCallbackParams^ wintRtInstance);
  ::Windows::UI::Xaml::ApplicationInitializationCallbackParams^ UnwrapApplicationInitializationCallbackParams(Local<Value> value);
  
  v8::Local<v8::Value> WrapBindingFailedEventArgs(::Windows::UI::Xaml::BindingFailedEventArgs^ wintRtInstance);
  ::Windows::UI::Xaml::BindingFailedEventArgs^ UnwrapBindingFailedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapBringIntoViewOptions(::Windows::UI::Xaml::BringIntoViewOptions^ wintRtInstance);
  ::Windows::UI::Xaml::BringIntoViewOptions^ UnwrapBringIntoViewOptions(Local<Value> value);
  
  v8::Local<v8::Value> WrapRoutedEventArgs(::Windows::UI::Xaml::RoutedEventArgs^ wintRtInstance);
  ::Windows::UI::Xaml::RoutedEventArgs^ UnwrapRoutedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapBringIntoViewRequestedEventArgs(::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^ wintRtInstance);
  ::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^ UnwrapBringIntoViewRequestedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapBrushTransition(::Windows::UI::Xaml::BrushTransition^ wintRtInstance);
  ::Windows::UI::Xaml::BrushTransition^ UnwrapBrushTransition(Local<Value> value);
  
  v8::Local<v8::Value> WrapResourceDictionary(::Windows::UI::Xaml::ResourceDictionary^ wintRtInstance);
  ::Windows::UI::Xaml::ResourceDictionary^ UnwrapResourceDictionary(Local<Value> value);
  
  v8::Local<v8::Value> WrapColorPaletteResources(::Windows::UI::Xaml::ColorPaletteResources^ wintRtInstance);
  ::Windows::UI::Xaml::ColorPaletteResources^ UnwrapColorPaletteResources(Local<Value> value);
  
  v8::Local<v8::Value> WrapUIElement(::Windows::UI::Xaml::UIElement^ wintRtInstance);
  ::Windows::UI::Xaml::UIElement^ UnwrapUIElement(Local<Value> value);
  
  v8::Local<v8::Value> WrapFrameworkElement(::Windows::UI::Xaml::FrameworkElement^ wintRtInstance);
  ::Windows::UI::Xaml::FrameworkElement^ UnwrapFrameworkElement(Local<Value> value);
  
  v8::Local<v8::Value> WrapFrameworkTemplate(::Windows::UI::Xaml::FrameworkTemplate^ wintRtInstance);
  ::Windows::UI::Xaml::FrameworkTemplate^ UnwrapFrameworkTemplate(Local<Value> value);
  
  v8::Local<v8::Value> WrapDataContextChangedEventArgs(::Windows::UI::Xaml::DataContextChangedEventArgs^ wintRtInstance);
  ::Windows::UI::Xaml::DataContextChangedEventArgs^ UnwrapDataContextChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapDataTemplate(::Windows::UI::Xaml::DataTemplate^ wintRtInstance);
  ::Windows::UI::Xaml::DataTemplate^ UnwrapDataTemplate(Local<Value> value);
  
  v8::Local<v8::Value> WrapDataTemplateKey(::Windows::UI::Xaml::DataTemplateKey^ wintRtInstance);
  ::Windows::UI::Xaml::DataTemplateKey^ UnwrapDataTemplateKey(Local<Value> value);
  
  v8::Local<v8::Value> WrapDebugSettings(::Windows::UI::Xaml::DebugSettings^ wintRtInstance);
  ::Windows::UI::Xaml::DebugSettings^ UnwrapDebugSettings(Local<Value> value);
  
  v8::Local<v8::Value> WrapDependencyObjectCollection(::Windows::UI::Xaml::DependencyObjectCollection^ wintRtInstance);
  ::Windows::UI::Xaml::DependencyObjectCollection^ UnwrapDependencyObjectCollection(Local<Value> value);
  
  v8::Local<v8::Value> WrapDependencyProperty(::Windows::UI::Xaml::DependencyProperty^ wintRtInstance);
  ::Windows::UI::Xaml::DependencyProperty^ UnwrapDependencyProperty(Local<Value> value);
  
  v8::Local<v8::Value> WrapDependencyPropertyChangedEventArgs(::Windows::UI::Xaml::DependencyPropertyChangedEventArgs^ wintRtInstance);
  ::Windows::UI::Xaml::DependencyPropertyChangedEventArgs^ UnwrapDependencyPropertyChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapDispatcherTimer(::Windows::UI::Xaml::DispatcherTimer^ wintRtInstance);
  ::Windows::UI::Xaml::DispatcherTimer^ UnwrapDispatcherTimer(Local<Value> value);
  
  v8::Local<v8::Value> WrapDragEventArgs(::Windows::UI::Xaml::DragEventArgs^ wintRtInstance);
  ::Windows::UI::Xaml::DragEventArgs^ UnwrapDragEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapDragOperationDeferral(::Windows::UI::Xaml::DragOperationDeferral^ wintRtInstance);
  ::Windows::UI::Xaml::DragOperationDeferral^ UnwrapDragOperationDeferral(Local<Value> value);
  
  v8::Local<v8::Value> WrapDragStartingEventArgs(::Windows::UI::Xaml::DragStartingEventArgs^ wintRtInstance);
  ::Windows::UI::Xaml::DragStartingEventArgs^ UnwrapDragStartingEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapDragUI(::Windows::UI::Xaml::DragUI^ wintRtInstance);
  ::Windows::UI::Xaml::DragUI^ UnwrapDragUI(Local<Value> value);
  
  v8::Local<v8::Value> WrapDragUIOverride(::Windows::UI::Xaml::DragUIOverride^ wintRtInstance);
  ::Windows::UI::Xaml::DragUIOverride^ UnwrapDragUIOverride(Local<Value> value);
  
  v8::Local<v8::Value> WrapDropCompletedEventArgs(::Windows::UI::Xaml::DropCompletedEventArgs^ wintRtInstance);
  ::Windows::UI::Xaml::DropCompletedEventArgs^ UnwrapDropCompletedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapEffectiveViewportChangedEventArgs(::Windows::UI::Xaml::EffectiveViewportChangedEventArgs^ wintRtInstance);
  ::Windows::UI::Xaml::EffectiveViewportChangedEventArgs^ UnwrapEffectiveViewportChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapElementFactoryGetArgs(::Windows::UI::Xaml::ElementFactoryGetArgs^ wintRtInstance);
  ::Windows::UI::Xaml::ElementFactoryGetArgs^ UnwrapElementFactoryGetArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapElementFactoryRecycleArgs(::Windows::UI::Xaml::ElementFactoryRecycleArgs^ wintRtInstance);
  ::Windows::UI::Xaml::ElementFactoryRecycleArgs^ UnwrapElementFactoryRecycleArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapElementSoundPlayer(::Windows::UI::Xaml::ElementSoundPlayer^ wintRtInstance);
  ::Windows::UI::Xaml::ElementSoundPlayer^ UnwrapElementSoundPlayer(Local<Value> value);
  
  v8::Local<v8::Value> WrapTriggerBase(::Windows::UI::Xaml::TriggerBase^ wintRtInstance);
  ::Windows::UI::Xaml::TriggerBase^ UnwrapTriggerBase(Local<Value> value);
  
  v8::Local<v8::Value> WrapEventTrigger(::Windows::UI::Xaml::EventTrigger^ wintRtInstance);
  ::Windows::UI::Xaml::EventTrigger^ UnwrapEventTrigger(Local<Value> value);
  
  v8::Local<v8::Value> WrapExceptionRoutedEventArgs(::Windows::UI::Xaml::ExceptionRoutedEventArgs^ wintRtInstance);
  ::Windows::UI::Xaml::ExceptionRoutedEventArgs^ UnwrapExceptionRoutedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapFrameworkView(::Windows::UI::Xaml::FrameworkView^ wintRtInstance);
  ::Windows::UI::Xaml::FrameworkView^ UnwrapFrameworkView(Local<Value> value);
  
  v8::Local<v8::Value> WrapFrameworkViewSource(::Windows::UI::Xaml::FrameworkViewSource^ wintRtInstance);
  ::Windows::UI::Xaml::FrameworkViewSource^ UnwrapFrameworkViewSource(Local<Value> value);
  
  v8::Local<v8::Value> WrapIDataTemplateExtension(::Windows::UI::Xaml::IDataTemplateExtension^ wintRtInstance);
  ::Windows::UI::Xaml::IDataTemplateExtension^ UnwrapIDataTemplateExtension(Local<Value> value);
  
  v8::Local<v8::Value> WrapIElementFactory(::Windows::UI::Xaml::IElementFactory^ wintRtInstance);
  ::Windows::UI::Xaml::IElementFactory^ UnwrapIElementFactory(Local<Value> value);
  
  v8::Local<v8::Value> WrapTriggerAction(::Windows::UI::Xaml::TriggerAction^ wintRtInstance);
  ::Windows::UI::Xaml::TriggerAction^ UnwrapTriggerAction(Local<Value> value);
  
  v8::Local<v8::Value> WrapMediaFailedRoutedEventArgs(::Windows::UI::Xaml::MediaFailedRoutedEventArgs^ wintRtInstance);
  ::Windows::UI::Xaml::MediaFailedRoutedEventArgs^ UnwrapMediaFailedRoutedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapPointHelper(::Windows::UI::Xaml::PointHelper^ wintRtInstance);
  ::Windows::UI::Xaml::PointHelper^ UnwrapPointHelper(Local<Value> value);
  
  v8::Local<v8::Value> WrapPropertyMetadata(::Windows::UI::Xaml::PropertyMetadata^ wintRtInstance);
  ::Windows::UI::Xaml::PropertyMetadata^ UnwrapPropertyMetadata(Local<Value> value);
  
  v8::Local<v8::Value> WrapPropertyPath(::Windows::UI::Xaml::PropertyPath^ wintRtInstance);
  ::Windows::UI::Xaml::PropertyPath^ UnwrapPropertyPath(Local<Value> value);
  
  v8::Local<v8::Value> WrapRectHelper(::Windows::UI::Xaml::RectHelper^ wintRtInstance);
  ::Windows::UI::Xaml::RectHelper^ UnwrapRectHelper(Local<Value> value);
  
  v8::Local<v8::Value> WrapRoutedEvent(::Windows::UI::Xaml::RoutedEvent^ wintRtInstance);
  ::Windows::UI::Xaml::RoutedEvent^ UnwrapRoutedEvent(Local<Value> value);
  
  v8::Local<v8::Value> WrapScalarTransition(::Windows::UI::Xaml::ScalarTransition^ wintRtInstance);
  ::Windows::UI::Xaml::ScalarTransition^ UnwrapScalarTransition(Local<Value> value);
  
  v8::Local<v8::Value> WrapSetterBase(::Windows::UI::Xaml::SetterBase^ wintRtInstance);
  ::Windows::UI::Xaml::SetterBase^ UnwrapSetterBase(Local<Value> value);
  
  v8::Local<v8::Value> WrapSetter(::Windows::UI::Xaml::Setter^ wintRtInstance);
  ::Windows::UI::Xaml::Setter^ UnwrapSetter(Local<Value> value);
  
  v8::Local<v8::Value> WrapSetterBaseCollection(::Windows::UI::Xaml::SetterBaseCollection^ wintRtInstance);
  ::Windows::UI::Xaml::SetterBaseCollection^ UnwrapSetterBaseCollection(Local<Value> value);
  
  v8::Local<v8::Value> WrapSizeChangedEventArgs(::Windows::UI::Xaml::SizeChangedEventArgs^ wintRtInstance);
  ::Windows::UI::Xaml::SizeChangedEventArgs^ UnwrapSizeChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapSizeHelper(::Windows::UI::Xaml::SizeHelper^ wintRtInstance);
  ::Windows::UI::Xaml::SizeHelper^ UnwrapSizeHelper(Local<Value> value);
  
  v8::Local<v8::Value> WrapStateTrigger(::Windows::UI::Xaml::StateTrigger^ wintRtInstance);
  ::Windows::UI::Xaml::StateTrigger^ UnwrapStateTrigger(Local<Value> value);
  
  v8::Local<v8::Value> WrapStyle(::Windows::UI::Xaml::Style^ wintRtInstance);
  ::Windows::UI::Xaml::Style^ UnwrapStyle(Local<Value> value);
  
  v8::Local<v8::Value> WrapStyleTypedPropertyAttribute(::Windows::UI::Xaml::StyleTypedPropertyAttribute^ wintRtInstance);
  ::Windows::UI::Xaml::StyleTypedPropertyAttribute^ UnwrapStyleTypedPropertyAttribute(Local<Value> value);
  
  v8::Local<v8::Value> WrapTargetPropertyPath(::Windows::UI::Xaml::TargetPropertyPath^ wintRtInstance);
  ::Windows::UI::Xaml::TargetPropertyPath^ UnwrapTargetPropertyPath(Local<Value> value);
  
  v8::Local<v8::Value> WrapTemplatePartAttribute(::Windows::UI::Xaml::TemplatePartAttribute^ wintRtInstance);
  ::Windows::UI::Xaml::TemplatePartAttribute^ UnwrapTemplatePartAttribute(Local<Value> value);
  
  v8::Local<v8::Value> WrapTemplateVisualStateAttribute(::Windows::UI::Xaml::TemplateVisualStateAttribute^ wintRtInstance);
  ::Windows::UI::Xaml::TemplateVisualStateAttribute^ UnwrapTemplateVisualStateAttribute(Local<Value> value);
  
  v8::Local<v8::Value> WrapTriggerActionCollection(::Windows::UI::Xaml::TriggerActionCollection^ wintRtInstance);
  ::Windows::UI::Xaml::TriggerActionCollection^ UnwrapTriggerActionCollection(Local<Value> value);
  
  v8::Local<v8::Value> WrapTriggerCollection(::Windows::UI::Xaml::TriggerCollection^ wintRtInstance);
  ::Windows::UI::Xaml::TriggerCollection^ UnwrapTriggerCollection(Local<Value> value);
  
  v8::Local<v8::Value> WrapUIElementWeakCollection(::Windows::UI::Xaml::UIElementWeakCollection^ wintRtInstance);
  ::Windows::UI::Xaml::UIElementWeakCollection^ UnwrapUIElementWeakCollection(Local<Value> value);
  
  v8::Local<v8::Value> WrapUnhandledExceptionEventArgs(::Windows::UI::Xaml::UnhandledExceptionEventArgs^ wintRtInstance);
  ::Windows::UI::Xaml::UnhandledExceptionEventArgs^ UnwrapUnhandledExceptionEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapVector3Transition(::Windows::UI::Xaml::Vector3Transition^ wintRtInstance);
  ::Windows::UI::Xaml::Vector3Transition^ UnwrapVector3Transition(Local<Value> value);
  
  v8::Local<v8::Value> WrapVisualState(::Windows::UI::Xaml::VisualState^ wintRtInstance);
  ::Windows::UI::Xaml::VisualState^ UnwrapVisualState(Local<Value> value);
  
  v8::Local<v8::Value> WrapVisualStateChangedEventArgs(::Windows::UI::Xaml::VisualStateChangedEventArgs^ wintRtInstance);
  ::Windows::UI::Xaml::VisualStateChangedEventArgs^ UnwrapVisualStateChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapVisualStateGroup(::Windows::UI::Xaml::VisualStateGroup^ wintRtInstance);
  ::Windows::UI::Xaml::VisualStateGroup^ UnwrapVisualStateGroup(Local<Value> value);
  
  v8::Local<v8::Value> WrapVisualStateManager(::Windows::UI::Xaml::VisualStateManager^ wintRtInstance);
  ::Windows::UI::Xaml::VisualStateManager^ UnwrapVisualStateManager(Local<Value> value);
  
  v8::Local<v8::Value> WrapVisualTransition(::Windows::UI::Xaml::VisualTransition^ wintRtInstance);
  ::Windows::UI::Xaml::VisualTransition^ UnwrapVisualTransition(Local<Value> value);
  
  v8::Local<v8::Value> WrapWindow(::Windows::UI::Xaml::Window^ wintRtInstance);
  ::Windows::UI::Xaml::Window^ UnwrapWindow(Local<Value> value);
  
  v8::Local<v8::Value> WrapWindowCreatedEventArgs(::Windows::UI::Xaml::WindowCreatedEventArgs^ wintRtInstance);
  ::Windows::UI::Xaml::WindowCreatedEventArgs^ UnwrapWindowCreatedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapXamlRoot(::Windows::UI::Xaml::XamlRoot^ wintRtInstance);
  ::Windows::UI::Xaml::XamlRoot^ UnwrapXamlRoot(Local<Value> value);
  
  v8::Local<v8::Value> WrapXamlRootChangedEventArgs(::Windows::UI::Xaml::XamlRootChangedEventArgs^ wintRtInstance);
  ::Windows::UI::Xaml::XamlRootChangedEventArgs^ UnwrapXamlRootChangedEventArgs(Local<Value> value);
  



  static void InitApplicationHighContrastAdjustmentEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("ApplicationHighContrastAdjustment").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::ApplicationHighContrastAdjustment::None)));
    Nan::Set(enumObject, Nan::New<String>("auto").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::ApplicationHighContrastAdjustment::Auto)));
  }

  static void InitApplicationRequiresPointerModeEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("ApplicationRequiresPointerMode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("auto").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::ApplicationRequiresPointerMode::Auto)));
    Nan::Set(enumObject, Nan::New<String>("whenRequested").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::ApplicationRequiresPointerMode::WhenRequested)));
  }

  static void InitApplicationThemeEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("ApplicationTheme").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("light").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::ApplicationTheme::Light)));
    Nan::Set(enumObject, Nan::New<String>("dark").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::ApplicationTheme::Dark)));
  }

  static void InitAutomationTextAttributesEnumEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("AutomationTextAttributesEnum").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("animationStyleAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::AnimationStyleAttribute)));
    Nan::Set(enumObject, Nan::New<String>("backgroundColorAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::BackgroundColorAttribute)));
    Nan::Set(enumObject, Nan::New<String>("bulletStyleAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::BulletStyleAttribute)));
    Nan::Set(enumObject, Nan::New<String>("capStyleAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::CapStyleAttribute)));
    Nan::Set(enumObject, Nan::New<String>("cultureAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::CultureAttribute)));
    Nan::Set(enumObject, Nan::New<String>("fontNameAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::FontNameAttribute)));
    Nan::Set(enumObject, Nan::New<String>("fontSizeAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::FontSizeAttribute)));
    Nan::Set(enumObject, Nan::New<String>("fontWeightAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::FontWeightAttribute)));
    Nan::Set(enumObject, Nan::New<String>("foregroundColorAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::ForegroundColorAttribute)));
    Nan::Set(enumObject, Nan::New<String>("horizontalTextAlignmentAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::HorizontalTextAlignmentAttribute)));
    Nan::Set(enumObject, Nan::New<String>("indentationFirstLineAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::IndentationFirstLineAttribute)));
    Nan::Set(enumObject, Nan::New<String>("indentationLeadingAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::IndentationLeadingAttribute)));
    Nan::Set(enumObject, Nan::New<String>("indentationTrailingAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::IndentationTrailingAttribute)));
    Nan::Set(enumObject, Nan::New<String>("isHiddenAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::IsHiddenAttribute)));
    Nan::Set(enumObject, Nan::New<String>("isItalicAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::IsItalicAttribute)));
    Nan::Set(enumObject, Nan::New<String>("isReadOnlyAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::IsReadOnlyAttribute)));
    Nan::Set(enumObject, Nan::New<String>("isSubscriptAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::IsSubscriptAttribute)));
    Nan::Set(enumObject, Nan::New<String>("isSuperscriptAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::IsSuperscriptAttribute)));
    Nan::Set(enumObject, Nan::New<String>("marginBottomAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::MarginBottomAttribute)));
    Nan::Set(enumObject, Nan::New<String>("marginLeadingAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::MarginLeadingAttribute)));
    Nan::Set(enumObject, Nan::New<String>("marginTopAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::MarginTopAttribute)));
    Nan::Set(enumObject, Nan::New<String>("marginTrailingAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::MarginTrailingAttribute)));
    Nan::Set(enumObject, Nan::New<String>("outlineStylesAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::OutlineStylesAttribute)));
    Nan::Set(enumObject, Nan::New<String>("overlineColorAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::OverlineColorAttribute)));
    Nan::Set(enumObject, Nan::New<String>("overlineStyleAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::OverlineStyleAttribute)));
    Nan::Set(enumObject, Nan::New<String>("strikethroughColorAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::StrikethroughColorAttribute)));
    Nan::Set(enumObject, Nan::New<String>("strikethroughStyleAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::StrikethroughStyleAttribute)));
    Nan::Set(enumObject, Nan::New<String>("tabsAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::TabsAttribute)));
    Nan::Set(enumObject, Nan::New<String>("textFlowDirectionsAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::TextFlowDirectionsAttribute)));
    Nan::Set(enumObject, Nan::New<String>("underlineColorAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::UnderlineColorAttribute)));
    Nan::Set(enumObject, Nan::New<String>("underlineStyleAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::UnderlineStyleAttribute)));
    Nan::Set(enumObject, Nan::New<String>("annotationTypesAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::AnnotationTypesAttribute)));
    Nan::Set(enumObject, Nan::New<String>("annotationObjectsAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::AnnotationObjectsAttribute)));
    Nan::Set(enumObject, Nan::New<String>("styleNameAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::StyleNameAttribute)));
    Nan::Set(enumObject, Nan::New<String>("styleIdAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::StyleIdAttribute)));
    Nan::Set(enumObject, Nan::New<String>("linkAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::LinkAttribute)));
    Nan::Set(enumObject, Nan::New<String>("isActiveAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::IsActiveAttribute)));
    Nan::Set(enumObject, Nan::New<String>("selectionActiveEndAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::SelectionActiveEndAttribute)));
    Nan::Set(enumObject, Nan::New<String>("caretPositionAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::CaretPositionAttribute)));
    Nan::Set(enumObject, Nan::New<String>("caretBidiModeAttribute").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::AutomationTextAttributesEnum::CaretBidiModeAttribute)));
  }

  static void InitElementHighContrastAdjustmentEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("ElementHighContrastAdjustment").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::ElementHighContrastAdjustment::None)));
    Nan::Set(enumObject, Nan::New<String>("application").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::ElementHighContrastAdjustment::Application)));
    Nan::Set(enumObject, Nan::New<String>("auto").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::ElementHighContrastAdjustment::Auto)));
  }

  static void InitElementSoundKindEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("ElementSoundKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("focus").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::ElementSoundKind::Focus)));
    Nan::Set(enumObject, Nan::New<String>("invoke").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::ElementSoundKind::Invoke)));
    Nan::Set(enumObject, Nan::New<String>("show").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::ElementSoundKind::Show)));
    Nan::Set(enumObject, Nan::New<String>("hide").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::ElementSoundKind::Hide)));
    Nan::Set(enumObject, Nan::New<String>("movePrevious").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::ElementSoundKind::MovePrevious)));
    Nan::Set(enumObject, Nan::New<String>("moveNext").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::ElementSoundKind::MoveNext)));
    Nan::Set(enumObject, Nan::New<String>("goBack").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::ElementSoundKind::GoBack)));
  }

  static void InitElementSoundModeEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("ElementSoundMode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("default").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::ElementSoundMode::Default)));
    Nan::Set(enumObject, Nan::New<String>("focusOnly").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::ElementSoundMode::FocusOnly)));
    Nan::Set(enumObject, Nan::New<String>("off").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::ElementSoundMode::Off)));
  }

  static void InitElementSoundPlayerStateEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("ElementSoundPlayerState").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("auto").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::ElementSoundPlayerState::Auto)));
    Nan::Set(enumObject, Nan::New<String>("off").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::ElementSoundPlayerState::Off)));
    Nan::Set(enumObject, Nan::New<String>("on").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::ElementSoundPlayerState::On)));
  }

  static void InitElementSpatialAudioModeEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("ElementSpatialAudioMode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("auto").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::ElementSpatialAudioMode::Auto)));
    Nan::Set(enumObject, Nan::New<String>("off").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::ElementSpatialAudioMode::Off)));
    Nan::Set(enumObject, Nan::New<String>("on").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::ElementSpatialAudioMode::On)));
  }

  static void InitElementThemeEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("ElementTheme").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("default").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::ElementTheme::Default)));
    Nan::Set(enumObject, Nan::New<String>("light").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::ElementTheme::Light)));
    Nan::Set(enumObject, Nan::New<String>("dark").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::ElementTheme::Dark)));
  }

  static void InitFlowDirectionEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("FlowDirection").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("leftToRight").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FlowDirection::LeftToRight)));
    Nan::Set(enumObject, Nan::New<String>("rightToLeft").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FlowDirection::RightToLeft)));
  }

  static void InitFocusStateEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("FocusState").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("unfocused").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FocusState::Unfocused)));
    Nan::Set(enumObject, Nan::New<String>("pointer").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FocusState::Pointer)));
    Nan::Set(enumObject, Nan::New<String>("keyboard").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FocusState::Keyboard)));
    Nan::Set(enumObject, Nan::New<String>("programmatic").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FocusState::Programmatic)));
  }

  static void InitFocusVisualKindEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("FocusVisualKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("dottedLine").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FocusVisualKind::DottedLine)));
    Nan::Set(enumObject, Nan::New<String>("highVisibility").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FocusVisualKind::HighVisibility)));
    Nan::Set(enumObject, Nan::New<String>("reveal").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FocusVisualKind::Reveal)));
  }

  static void InitFontCapitalsEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("FontCapitals").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("normal").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontCapitals::Normal)));
    Nan::Set(enumObject, Nan::New<String>("allSmallCaps").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontCapitals::AllSmallCaps)));
    Nan::Set(enumObject, Nan::New<String>("smallCaps").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontCapitals::SmallCaps)));
    Nan::Set(enumObject, Nan::New<String>("allPetiteCaps").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontCapitals::AllPetiteCaps)));
    Nan::Set(enumObject, Nan::New<String>("petiteCaps").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontCapitals::PetiteCaps)));
    Nan::Set(enumObject, Nan::New<String>("unicase").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontCapitals::Unicase)));
    Nan::Set(enumObject, Nan::New<String>("titling").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontCapitals::Titling)));
  }

  static void InitFontEastAsianLanguageEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("FontEastAsianLanguage").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("normal").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontEastAsianLanguage::Normal)));
    Nan::Set(enumObject, Nan::New<String>("hojoKanji").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontEastAsianLanguage::HojoKanji)));
    Nan::Set(enumObject, Nan::New<String>("jis04").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontEastAsianLanguage::Jis04)));
    Nan::Set(enumObject, Nan::New<String>("jis78").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontEastAsianLanguage::Jis78)));
    Nan::Set(enumObject, Nan::New<String>("jis83").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontEastAsianLanguage::Jis83)));
    Nan::Set(enumObject, Nan::New<String>("jis90").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontEastAsianLanguage::Jis90)));
    Nan::Set(enumObject, Nan::New<String>("nlcKanji").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontEastAsianLanguage::NlcKanji)));
    Nan::Set(enumObject, Nan::New<String>("simplified").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontEastAsianLanguage::Simplified)));
    Nan::Set(enumObject, Nan::New<String>("traditional").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontEastAsianLanguage::Traditional)));
    Nan::Set(enumObject, Nan::New<String>("traditionalNames").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontEastAsianLanguage::TraditionalNames)));
  }

  static void InitFontEastAsianWidthsEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("FontEastAsianWidths").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("normal").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontEastAsianWidths::Normal)));
    Nan::Set(enumObject, Nan::New<String>("full").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontEastAsianWidths::Full)));
    Nan::Set(enumObject, Nan::New<String>("half").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontEastAsianWidths::Half)));
    Nan::Set(enumObject, Nan::New<String>("proportional").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontEastAsianWidths::Proportional)));
    Nan::Set(enumObject, Nan::New<String>("quarter").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontEastAsianWidths::Quarter)));
    Nan::Set(enumObject, Nan::New<String>("third").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontEastAsianWidths::Third)));
  }

  static void InitFontFractionEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("FontFraction").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("normal").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontFraction::Normal)));
    Nan::Set(enumObject, Nan::New<String>("stacked").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontFraction::Stacked)));
    Nan::Set(enumObject, Nan::New<String>("slashed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontFraction::Slashed)));
  }

  static void InitFontNumeralAlignmentEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("FontNumeralAlignment").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("normal").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontNumeralAlignment::Normal)));
    Nan::Set(enumObject, Nan::New<String>("proportional").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontNumeralAlignment::Proportional)));
    Nan::Set(enumObject, Nan::New<String>("tabular").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontNumeralAlignment::Tabular)));
  }

  static void InitFontNumeralStyleEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("FontNumeralStyle").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("normal").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontNumeralStyle::Normal)));
    Nan::Set(enumObject, Nan::New<String>("lining").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontNumeralStyle::Lining)));
    Nan::Set(enumObject, Nan::New<String>("oldStyle").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontNumeralStyle::OldStyle)));
  }

  static void InitFontVariantsEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("FontVariants").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("normal").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontVariants::Normal)));
    Nan::Set(enumObject, Nan::New<String>("superscript").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontVariants::Superscript)));
    Nan::Set(enumObject, Nan::New<String>("subscript").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontVariants::Subscript)));
    Nan::Set(enumObject, Nan::New<String>("ordinal").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontVariants::Ordinal)));
    Nan::Set(enumObject, Nan::New<String>("inferior").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontVariants::Inferior)));
    Nan::Set(enumObject, Nan::New<String>("ruby").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::FontVariants::Ruby)));
  }

  static void InitHorizontalAlignmentEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("HorizontalAlignment").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("left").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::HorizontalAlignment::Left)));
    Nan::Set(enumObject, Nan::New<String>("center").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::HorizontalAlignment::Center)));
    Nan::Set(enumObject, Nan::New<String>("right").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::HorizontalAlignment::Right)));
    Nan::Set(enumObject, Nan::New<String>("stretch").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::HorizontalAlignment::Stretch)));
  }

  static void InitLineStackingStrategyEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("LineStackingStrategy").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("maxHeight").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::LineStackingStrategy::MaxHeight)));
    Nan::Set(enumObject, Nan::New<String>("blockLineHeight").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::LineStackingStrategy::BlockLineHeight)));
    Nan::Set(enumObject, Nan::New<String>("baselineToBaseline").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::LineStackingStrategy::BaselineToBaseline)));
  }

  static void InitOpticalMarginAlignmentEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("OpticalMarginAlignment").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::OpticalMarginAlignment::None)));
    Nan::Set(enumObject, Nan::New<String>("trimSideBearings").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::OpticalMarginAlignment::TrimSideBearings)));
  }

  static void InitTextAlignmentEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("TextAlignment").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("center").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::TextAlignment::Center)));
    Nan::Set(enumObject, Nan::New<String>("left").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::TextAlignment::Left)));
    Nan::Set(enumObject, Nan::New<String>("start").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::TextAlignment::Start)));
    Nan::Set(enumObject, Nan::New<String>("right").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::TextAlignment::Right)));
    Nan::Set(enumObject, Nan::New<String>("end").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::TextAlignment::End)));
    Nan::Set(enumObject, Nan::New<String>("justify").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::TextAlignment::Justify)));
    Nan::Set(enumObject, Nan::New<String>("detectFromContent").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::TextAlignment::DetectFromContent)));
  }

  static void InitTextLineBoundsEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("TextLineBounds").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("full").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::TextLineBounds::Full)));
    Nan::Set(enumObject, Nan::New<String>("trimToCapHeight").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::TextLineBounds::TrimToCapHeight)));
    Nan::Set(enumObject, Nan::New<String>("trimToBaseline").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::TextLineBounds::TrimToBaseline)));
    Nan::Set(enumObject, Nan::New<String>("tight").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::TextLineBounds::Tight)));
  }

  static void InitTextReadingOrderEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("TextReadingOrder").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("default").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::TextReadingOrder::Default)));
    Nan::Set(enumObject, Nan::New<String>("useFlowDirection").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::TextReadingOrder::UseFlowDirection)));
    Nan::Set(enumObject, Nan::New<String>("detectFromContent").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::TextReadingOrder::DetectFromContent)));
  }

  static void InitTextTrimmingEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("TextTrimming").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::TextTrimming::None)));
    Nan::Set(enumObject, Nan::New<String>("characterEllipsis").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::TextTrimming::CharacterEllipsis)));
    Nan::Set(enumObject, Nan::New<String>("wordEllipsis").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::TextTrimming::WordEllipsis)));
    Nan::Set(enumObject, Nan::New<String>("clip").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::TextTrimming::Clip)));
  }

  static void InitTextWrappingEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("TextWrapping").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("noWrap").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::TextWrapping::NoWrap)));
    Nan::Set(enumObject, Nan::New<String>("wrap").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::TextWrapping::Wrap)));
    Nan::Set(enumObject, Nan::New<String>("wrapWholeWords").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::TextWrapping::WrapWholeWords)));
  }

  static void InitVector3TransitionComponentsEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("Vector3TransitionComponents").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("x").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::Vector3TransitionComponents::X)));
    Nan::Set(enumObject, Nan::New<String>("y").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::Vector3TransitionComponents::Y)));
    Nan::Set(enumObject, Nan::New<String>("z").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::Vector3TransitionComponents::Z)));
  }

  static void InitVerticalAlignmentEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("VerticalAlignment").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("top").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::VerticalAlignment::Top)));
    Nan::Set(enumObject, Nan::New<String>("center").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::VerticalAlignment::Center)));
    Nan::Set(enumObject, Nan::New<String>("bottom").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::VerticalAlignment::Bottom)));
    Nan::Set(enumObject, Nan::New<String>("stretch").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::VerticalAlignment::Stretch)));
  }

  static void InitVisibilityEnum(const Local<Object> exports) {
    HandleScope scope;

    Local<Object> enumObject = Nan::New<Object>();

    Nan::Set(exports, Nan::New<String>("Visibility").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("visible").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::Visibility::Visible)));
    Nan::Set(enumObject, Nan::New<String>("collapsed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Xaml::Visibility::Collapsed)));
  }


  static bool IsRectJsObject(Local<Value> value) {
    if (!value->IsObject()) {
      return false;
    }

    Local<String> symbol;
    Local<Object> obj = Nan::To<Object>(value).ToLocalChecked();

    return true;
  }

  ::Windows::Foundation::Rect RectFromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::Foundation::Rect returnValue;

    if (!value->IsObject()) {
      Nan::ThrowError(Nan::TypeError(NodeRT::Utils::NewString(L"Unexpected type, expected an object")));
      return returnValue;
    }

    Local<Object> obj = Nan::To<Object>(value).ToLocalChecked();
    Local<String> symbol;

    return returnValue;
  }

  Local<Value> RectToJsObject(::Windows::Foundation::Rect value) {
    EscapableHandleScope scope;

    Local<Object> obj = Nan::New<Object>();


    return scope.Escape(obj);
  }
  static bool IsColorJsObject(Local<Value> value) {
    if (!value->IsObject()) {
      return false;
    }

    Local<String> symbol;
    Local<Object> obj = Nan::To<Object>(value).ToLocalChecked();

    return true;
  }

  ::Windows::UI::Color ColorFromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::UI::Color returnValue;

    if (!value->IsObject()) {
      Nan::ThrowError(Nan::TypeError(NodeRT::Utils::NewString(L"Unexpected type, expected an object")));
      return returnValue;
    }

    Local<Object> obj = Nan::To<Object>(value).ToLocalChecked();
    Local<String> symbol;

    return returnValue;
  }

  Local<Value> ColorToJsObject(::Windows::UI::Color value) {
    EscapableHandleScope scope;

    Local<Object> obj = Nan::New<Object>();


    return scope.Escape(obj);
  }
  static bool IsPointJsObject(Local<Value> value) {
    if (!value->IsObject()) {
      return false;
    }

    Local<String> symbol;
    Local<Object> obj = Nan::To<Object>(value).ToLocalChecked();

    return true;
  }

  ::Windows::Foundation::Point PointFromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::Foundation::Point returnValue;

    if (!value->IsObject()) {
      Nan::ThrowError(Nan::TypeError(NodeRT::Utils::NewString(L"Unexpected type, expected an object")));
      return returnValue;
    }

    Local<Object> obj = Nan::To<Object>(value).ToLocalChecked();
    Local<String> symbol;

    return returnValue;
  }

  Local<Value> PointToJsObject(::Windows::Foundation::Point value) {
    EscapableHandleScope scope;

    Local<Object> obj = Nan::New<Object>();


    return scope.Escape(obj);
  }
  static bool IsSizeJsObject(Local<Value> value) {
    if (!value->IsObject()) {
      return false;
    }

    Local<String> symbol;
    Local<Object> obj = Nan::To<Object>(value).ToLocalChecked();

    return true;
  }

  ::Windows::Foundation::Size SizeFromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::Foundation::Size returnValue;

    if (!value->IsObject()) {
      Nan::ThrowError(Nan::TypeError(NodeRT::Utils::NewString(L"Unexpected type, expected an object")));
      return returnValue;
    }

    Local<Object> obj = Nan::To<Object>(value).ToLocalChecked();
    Local<String> symbol;

    return returnValue;
  }

  Local<Value> SizeToJsObject(::Windows::Foundation::Size value) {
    EscapableHandleScope scope;

    Local<Object> obj = Nan::New<Object>();


    return scope.Escape(obj);
  }
  static bool IsVector3JsObject(Local<Value> value) {
    if (!value->IsObject()) {
      return false;
    }

    Local<String> symbol;
    Local<Object> obj = Nan::To<Object>(value).ToLocalChecked();

    symbol = Nan::New<String>("x").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("y").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("z").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    return true;
  }

  ::Platform::Numerics::Vector3 Vector3FromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Platform::Numerics::Vector3 returnValue;

    if (!value->IsObject()) {
      Nan::ThrowError(Nan::TypeError(NodeRT::Utils::NewString(L"Unexpected type, expected an object")));
      return returnValue;
    }

    Local<Object> obj = Nan::To<Object>(value).ToLocalChecked();
    Local<String> symbol;

    symbol = Nan::New<String>("x").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.X = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("y").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.Y = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("z").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.Z = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    return returnValue;
  }

  Local<Value> Vector3ToJsObject(::Platform::Numerics::Vector3 value) {
    EscapableHandleScope scope;

    Local<Object> obj = Nan::New<Object>();

    Nan::Set(obj, Nan::New<String>("x").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.X)));
    Nan::Set(obj, Nan::New<String>("y").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.Y)));
    Nan::Set(obj, Nan::New<String>("z").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.Z)));

    return scope.Escape(obj);
  }
  static bool IsVector2JsObject(Local<Value> value) {
    if (!value->IsObject()) {
      return false;
    }

    Local<String> symbol;
    Local<Object> obj = Nan::To<Object>(value).ToLocalChecked();

    symbol = Nan::New<String>("x").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("y").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    return true;
  }

  ::Platform::Numerics::Vector2 Vector2FromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Platform::Numerics::Vector2 returnValue;

    if (!value->IsObject()) {
      Nan::ThrowError(Nan::TypeError(NodeRT::Utils::NewString(L"Unexpected type, expected an object")));
      return returnValue;
    }

    Local<Object> obj = Nan::To<Object>(value).ToLocalChecked();
    Local<String> symbol;

    symbol = Nan::New<String>("x").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.X = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("y").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.Y = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    return returnValue;
  }

  Local<Value> Vector2ToJsObject(::Platform::Numerics::Vector2 value) {
    EscapableHandleScope scope;

    Local<Object> obj = Nan::New<Object>();

    Nan::Set(obj, Nan::New<String>("x").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.X)));
    Nan::Set(obj, Nan::New<String>("y").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.Y)));

    return scope.Escape(obj);
  }
  static bool IsMatrix4x4JsObject(Local<Value> value) {
    if (!value->IsObject()) {
      return false;
    }

    Local<String> symbol;
    Local<Object> obj = Nan::To<Object>(value).ToLocalChecked();

    symbol = Nan::New<String>("m11").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("m12").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("m13").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("m14").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("m21").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("m22").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("m23").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("m24").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("m31").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("m32").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("m33").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("m34").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("m41").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("m42").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("m43").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("m44").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    return true;
  }

  ::Platform::Numerics::Matrix4x4 Matrix4x4FromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Platform::Numerics::Matrix4x4 returnValue;

    if (!value->IsObject()) {
      Nan::ThrowError(Nan::TypeError(NodeRT::Utils::NewString(L"Unexpected type, expected an object")));
      return returnValue;
    }

    Local<Object> obj = Nan::To<Object>(value).ToLocalChecked();
    Local<String> symbol;

    symbol = Nan::New<String>("m11").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.M11 = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("m12").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.M12 = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("m13").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.M13 = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("m14").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.M14 = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("m21").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.M21 = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("m22").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.M22 = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("m23").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.M23 = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("m24").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.M24 = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("m31").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.M31 = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("m32").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.M32 = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("m33").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.M33 = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("m34").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.M34 = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("m41").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.M41 = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("m42").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.M42 = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("m43").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.M43 = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("m44").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.M44 = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    return returnValue;
  }

  Local<Value> Matrix4x4ToJsObject(::Platform::Numerics::Matrix4x4 value) {
    EscapableHandleScope scope;

    Local<Object> obj = Nan::New<Object>();

    Nan::Set(obj, Nan::New<String>("m11").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.M11)));
    Nan::Set(obj, Nan::New<String>("m12").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.M12)));
    Nan::Set(obj, Nan::New<String>("m13").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.M13)));
    Nan::Set(obj, Nan::New<String>("m14").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.M14)));
    Nan::Set(obj, Nan::New<String>("m21").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.M21)));
    Nan::Set(obj, Nan::New<String>("m22").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.M22)));
    Nan::Set(obj, Nan::New<String>("m23").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.M23)));
    Nan::Set(obj, Nan::New<String>("m24").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.M24)));
    Nan::Set(obj, Nan::New<String>("m31").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.M31)));
    Nan::Set(obj, Nan::New<String>("m32").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.M32)));
    Nan::Set(obj, Nan::New<String>("m33").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.M33)));
    Nan::Set(obj, Nan::New<String>("m34").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.M34)));
    Nan::Set(obj, Nan::New<String>("m41").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.M41)));
    Nan::Set(obj, Nan::New<String>("m42").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.M42)));
    Nan::Set(obj, Nan::New<String>("m43").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.M43)));
    Nan::Set(obj, Nan::New<String>("m44").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.M44)));

    return scope.Escape(obj);
  }

  class DependencyObject : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("DependencyObject").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "getValue", GetValue);
            Nan::SetPrototypeMethod(localRef, "setValue", SetValue);
            Nan::SetPrototypeMethod(localRef, "clearValue", ClearValue);
            Nan::SetPrototypeMethod(localRef, "readLocalValue", ReadLocalValue);
            Nan::SetPrototypeMethod(localRef, "getAnimationBaseValue", GetAnimationBaseValue);
            Nan::SetPrototypeMethod(localRef, "registerPropertyChangedCallback", RegisterPropertyChangedCallback);
            Nan::SetPrototypeMethod(localRef, "unregisterPropertyChangedCallback", UnregisterPropertyChangedCallback);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("DependencyObject").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      DependencyObject(::Windows::UI::Xaml::DependencyObject^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::DependencyObject^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::DependencyObject^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      DependencyObject *wrapperInstance = new DependencyObject(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::DependencyObject^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::DependencyObject^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapDependencyObject(winRtInstance));
    }


    static void GetValue(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyProperty^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::DependencyProperty^ arg0 = UnwrapDependencyProperty(info[0]);
          
          ::Platform::Object^ result;
          result = wrapper->_instance->GetValue(arg0);
          info.GetReturnValue().Set(CreateOpaqueWrapper(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void SetValue(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyProperty^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[1]))
      {
        try
        {
          ::Windows::UI::Xaml::DependencyProperty^ arg0 = UnwrapDependencyProperty(info[0]);
          ::Platform::Object^ arg1 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          wrapper->_instance->SetValue(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void ClearValue(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyProperty^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::DependencyProperty^ arg0 = UnwrapDependencyProperty(info[0]);
          
          wrapper->_instance->ClearValue(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void ReadLocalValue(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyProperty^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::DependencyProperty^ arg0 = UnwrapDependencyProperty(info[0]);
          
          ::Platform::Object^ result;
          result = wrapper->_instance->ReadLocalValue(arg0);
          info.GetReturnValue().Set(CreateOpaqueWrapper(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetAnimationBaseValue(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyProperty^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::DependencyProperty^ arg0 = UnwrapDependencyProperty(info[0]);
          
          ::Platform::Object^ result;
          result = wrapper->_instance->GetAnimationBaseValue(arg0);
          info.GetReturnValue().Set(CreateOpaqueWrapper(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void RegisterPropertyChangedCallback(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyProperty^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyPropertyChangedCallback^>(info[1]))
      {
        try
        {
          ::Windows::UI::Xaml::DependencyProperty^ arg0 = UnwrapDependencyProperty(info[0]);
          ::Windows::UI::Xaml::DependencyPropertyChangedCallback^ arg1 = dynamic_cast<::Windows::UI::Xaml::DependencyPropertyChangedCallback^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          __int64 result;
          result = wrapper->_instance->RegisterPropertyChangedCallback(arg0, arg1);
          info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void UnregisterPropertyChangedCallback(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyProperty^>(info[0])
        && info[1]->IsNumber())
      {
        try
        {
          ::Windows::UI::Xaml::DependencyProperty^ arg0 = UnwrapDependencyProperty(info[0]);
          __int64 arg1 = Nan::To<int64_t>(info[1]).FromMaybe(0);
          
          wrapper->_instance->UnregisterPropertyChangedCallback(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    static void DispatcherGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      try  {
        ::Windows::UI::Core::CoreDispatcher^ result = wrapper->_instance->Dispatcher;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "CoreDispatcher", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::DependencyObject^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapDependencyObject(::Windows::UI::Xaml::DependencyObject^ wintRtInstance);
      friend ::Windows::UI::Xaml::DependencyObject^ UnwrapDependencyObject(Local<Value> value);
  };

  Persistent<FunctionTemplate> DependencyObject::s_constructorTemplate;

  v8::Local<v8::Value> WrapDependencyObject(::Windows::UI::Xaml::DependencyObject^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(DependencyObject::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::DependencyObject^ UnwrapDependencyObject(Local<Value> value) {
     return DependencyObject::Unwrap<DependencyObject>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitDependencyObject(Local<Object> exports) {
    DependencyObject::Init(exports);
  }

  class StateTriggerBase : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("StateTriggerBase").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "setActive", SetActive);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("StateTriggerBase").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      StateTriggerBase(::Windows::UI::Xaml::StateTriggerBase^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::StateTriggerBase^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::StateTriggerBase^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::StateTriggerBase^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      StateTriggerBase *wrapperInstance = new StateTriggerBase(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::StateTriggerBase^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::StateTriggerBase^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::StateTriggerBase^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapStateTriggerBase(winRtInstance));
    }


    static void SetActive(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::StateTriggerBase^>(info.This())) {
        return;
      }

      StateTriggerBase *wrapper = StateTriggerBase::Unwrap<StateTriggerBase>(info.This());

      if (info.Length() == 1
        && info[0]->IsBoolean())
      {
        try
        {
          bool arg0 = Nan::To<bool>(info[0]).FromMaybe(false);
          
          wrapper->_instance->SetActive(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    static void DispatcherGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      try  {
        ::Windows::UI::Core::CoreDispatcher^ result = wrapper->_instance->Dispatcher;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "CoreDispatcher", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::StateTriggerBase^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapStateTriggerBase(::Windows::UI::Xaml::StateTriggerBase^ wintRtInstance);
      friend ::Windows::UI::Xaml::StateTriggerBase^ UnwrapStateTriggerBase(Local<Value> value);
  };

  Persistent<FunctionTemplate> StateTriggerBase::s_constructorTemplate;

  v8::Local<v8::Value> WrapStateTriggerBase(::Windows::UI::Xaml::StateTriggerBase^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(StateTriggerBase::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::StateTriggerBase^ UnwrapStateTriggerBase(Local<Value> value) {
     return StateTriggerBase::Unwrap<StateTriggerBase>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitStateTriggerBase(Local<Object> exports) {
    StateTriggerBase::Init(exports);
  }

  class AdaptiveTrigger : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("AdaptiveTrigger").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("minWindowWidth").ToLocalChecked(), MinWindowWidthGetter, MinWindowWidthSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("minWindowHeight").ToLocalChecked(), MinWindowHeightGetter, MinWindowHeightSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetAccessor(constructor, Nan::New<String>("minWindowHeightProperty").ToLocalChecked(), MinWindowHeightPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("minWindowWidthProperty").ToLocalChecked(), MinWindowWidthPropertyGetter);


        Nan::Set(exports, Nan::New<String>("AdaptiveTrigger").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AdaptiveTrigger(::Windows::UI::Xaml::AdaptiveTrigger^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::AdaptiveTrigger^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::AdaptiveTrigger^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::AdaptiveTrigger^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::AdaptiveTrigger();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      AdaptiveTrigger *wrapperInstance = new AdaptiveTrigger(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::AdaptiveTrigger^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::AdaptiveTrigger^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::AdaptiveTrigger^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAdaptiveTrigger(winRtInstance));
    }





    static void MinWindowWidthGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::AdaptiveTrigger^>(info.This())) {
        return;
      }

      AdaptiveTrigger *wrapper = AdaptiveTrigger::Unwrap<AdaptiveTrigger>(info.This());

      try  {
        double result = wrapper->_instance->MinWindowWidth;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MinWindowWidthSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::AdaptiveTrigger^>(info.This())) {
        return;
      }

      AdaptiveTrigger *wrapper = AdaptiveTrigger::Unwrap<AdaptiveTrigger>(info.This());

      try {

        double winRtValue = Nan::To<double>(value).FromMaybe(0.0);

        wrapper->_instance->MinWindowWidth = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void MinWindowHeightGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::AdaptiveTrigger^>(info.This())) {
        return;
      }

      AdaptiveTrigger *wrapper = AdaptiveTrigger::Unwrap<AdaptiveTrigger>(info.This());

      try  {
        double result = wrapper->_instance->MinWindowHeight;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MinWindowHeightSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::AdaptiveTrigger^>(info.This())) {
        return;
      }

      AdaptiveTrigger *wrapper = AdaptiveTrigger::Unwrap<AdaptiveTrigger>(info.This());

      try {

        double winRtValue = Nan::To<double>(value).FromMaybe(0.0);

        wrapper->_instance->MinWindowHeight = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void DispatcherGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      try  {
        ::Windows::UI::Core::CoreDispatcher^ result = wrapper->_instance->Dispatcher;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "CoreDispatcher", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    static void MinWindowHeightPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::AdaptiveTrigger::MinWindowHeightProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void MinWindowWidthPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::AdaptiveTrigger::MinWindowWidthProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    private:
      ::Windows::UI::Xaml::AdaptiveTrigger^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAdaptiveTrigger(::Windows::UI::Xaml::AdaptiveTrigger^ wintRtInstance);
      friend ::Windows::UI::Xaml::AdaptiveTrigger^ UnwrapAdaptiveTrigger(Local<Value> value);
  };

  Persistent<FunctionTemplate> AdaptiveTrigger::s_constructorTemplate;

  v8::Local<v8::Value> WrapAdaptiveTrigger(::Windows::UI::Xaml::AdaptiveTrigger^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(AdaptiveTrigger::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::AdaptiveTrigger^ UnwrapAdaptiveTrigger(Local<Value> value) {
     return AdaptiveTrigger::Unwrap<AdaptiveTrigger>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAdaptiveTrigger(Local<Object> exports) {
    AdaptiveTrigger::Init(exports);
  }

  class Application : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("Application").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "exit", Exit);
            Nan::SetPrototypeMethod(localRef, "onActivated", OnActivated);
            Nan::SetPrototypeMethod(localRef, "onLaunched", OnLaunched);
            Nan::SetPrototypeMethod(localRef, "onFileActivated", OnFileActivated);
            Nan::SetPrototypeMethod(localRef, "onSearchActivated", OnSearchActivated);
            Nan::SetPrototypeMethod(localRef, "onShareTargetActivated", OnShareTargetActivated);
            Nan::SetPrototypeMethod(localRef, "onFileOpenPickerActivated", OnFileOpenPickerActivated);
            Nan::SetPrototypeMethod(localRef, "onFileSavePickerActivated", OnFileSavePickerActivated);
            Nan::SetPrototypeMethod(localRef, "onCachedFileUpdaterActivated", OnCachedFileUpdaterActivated);
            Nan::SetPrototypeMethod(localRef, "onWindowCreated", OnWindowCreated);
            Nan::SetPrototypeMethod(localRef, "onBackgroundActivated", OnBackgroundActivated);
          


          
          Nan::SetPrototypeMethod(localRef,"addListener", AddListener);
          Nan::SetPrototypeMethod(localRef,"on", AddListener);
          Nan::SetPrototypeMethod(localRef,"removeListener", RemoveListener);
          Nan::SetPrototypeMethod(localRef, "off", RemoveListener);

          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("resources").ToLocalChecked(), ResourcesGetter, ResourcesSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("requestedTheme").ToLocalChecked(), RequestedThemeGetter, RequestedThemeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("debugSettings").ToLocalChecked(), DebugSettingsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("requiresPointerMode").ToLocalChecked(), RequiresPointerModeGetter, RequiresPointerModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("focusVisualKind").ToLocalChecked(), FocusVisualKindGetter, FocusVisualKindSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("highContrastAdjustment").ToLocalChecked(), HighContrastAdjustmentGetter, HighContrastAdjustmentSetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetMethod(constructor, "start", Start);
        Nan::SetMethod(constructor, "loadComponent", LoadComponent);
        Nan::SetAccessor(constructor, Nan::New<String>("current").ToLocalChecked(), CurrentGetter);


        Nan::Set(exports, Nan::New<String>("Application").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      Application(::Windows::UI::Xaml::Application^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::Application^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::Application^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::Application();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      Application *wrapperInstance = new Application(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::Application^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::Application^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapApplication(winRtInstance));
    }


    static void Exit(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This())) {
        return;
      }

      Application *wrapper = Application::Unwrap<Application>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->Exit();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void OnActivated(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This())) {
        return;
      }

      Application *wrapper = Application::Unwrap<Application>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Activation::IActivatedEventArgs^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Activation::IActivatedEventArgs^ arg0 = dynamic_cast<::Windows::ApplicationModel::Activation::IActivatedEventArgs^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          wrapper->_instance->OnActivated(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void OnLaunched(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This())) {
        return;
      }

      Application *wrapper = Application::Unwrap<Application>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Activation::LaunchActivatedEventArgs^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Activation::LaunchActivatedEventArgs^ arg0 = dynamic_cast<::Windows::ApplicationModel::Activation::LaunchActivatedEventArgs^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          wrapper->_instance->OnLaunched(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void OnFileActivated(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This())) {
        return;
      }

      Application *wrapper = Application::Unwrap<Application>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Activation::FileActivatedEventArgs^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Activation::FileActivatedEventArgs^ arg0 = dynamic_cast<::Windows::ApplicationModel::Activation::FileActivatedEventArgs^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          wrapper->_instance->OnFileActivated(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void OnSearchActivated(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This())) {
        return;
      }

      Application *wrapper = Application::Unwrap<Application>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Activation::SearchActivatedEventArgs^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Activation::SearchActivatedEventArgs^ arg0 = dynamic_cast<::Windows::ApplicationModel::Activation::SearchActivatedEventArgs^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          wrapper->_instance->OnSearchActivated(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void OnShareTargetActivated(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This())) {
        return;
      }

      Application *wrapper = Application::Unwrap<Application>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Activation::ShareTargetActivatedEventArgs^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Activation::ShareTargetActivatedEventArgs^ arg0 = dynamic_cast<::Windows::ApplicationModel::Activation::ShareTargetActivatedEventArgs^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          wrapper->_instance->OnShareTargetActivated(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void OnFileOpenPickerActivated(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This())) {
        return;
      }

      Application *wrapper = Application::Unwrap<Application>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Activation::FileOpenPickerActivatedEventArgs^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Activation::FileOpenPickerActivatedEventArgs^ arg0 = dynamic_cast<::Windows::ApplicationModel::Activation::FileOpenPickerActivatedEventArgs^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          wrapper->_instance->OnFileOpenPickerActivated(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void OnFileSavePickerActivated(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This())) {
        return;
      }

      Application *wrapper = Application::Unwrap<Application>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Activation::FileSavePickerActivatedEventArgs^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Activation::FileSavePickerActivatedEventArgs^ arg0 = dynamic_cast<::Windows::ApplicationModel::Activation::FileSavePickerActivatedEventArgs^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          wrapper->_instance->OnFileSavePickerActivated(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void OnCachedFileUpdaterActivated(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This())) {
        return;
      }

      Application *wrapper = Application::Unwrap<Application>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Activation::CachedFileUpdaterActivatedEventArgs^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Activation::CachedFileUpdaterActivatedEventArgs^ arg0 = dynamic_cast<::Windows::ApplicationModel::Activation::CachedFileUpdaterActivatedEventArgs^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          wrapper->_instance->OnCachedFileUpdaterActivated(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void OnWindowCreated(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This())) {
        return;
      }

      Application *wrapper = Application::Unwrap<Application>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::WindowCreatedEventArgs^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::WindowCreatedEventArgs^ arg0 = UnwrapWindowCreatedEventArgs(info[0]);
          
          wrapper->_instance->OnWindowCreated(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void OnBackgroundActivated(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This())) {
        return;
      }

      Application *wrapper = Application::Unwrap<Application>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Activation::BackgroundActivatedEventArgs^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Activation::BackgroundActivatedEventArgs^ arg0 = dynamic_cast<::Windows::ApplicationModel::Activation::BackgroundActivatedEventArgs^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          wrapper->_instance->OnBackgroundActivated(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    static void Start(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ApplicationInitializationCallback^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::ApplicationInitializationCallback^ arg0 = dynamic_cast<::Windows::UI::Xaml::ApplicationInitializationCallback^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::UI::Xaml::Application::Start(arg0);
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void LoadComponent(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(info[1]))
      {
        try
        {
          ::Platform::Object^ arg0 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Foundation::Uri^ arg1 = dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          ::Windows::UI::Xaml::Application::LoadComponent(arg0, arg1);
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(info[1])
        && info[2]->IsInt32())
      {
        try
        {
          ::Platform::Object^ arg0 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Foundation::Uri^ arg1 = dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(info[1]));
          ::Windows::UI::Xaml::Controls::Primitives::ComponentResourceLocation arg2 = static_cast<::Windows::UI::Xaml::Controls::Primitives::ComponentResourceLocation>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          
          ::Windows::UI::Xaml::Application::LoadComponent(arg0, arg1, arg2);
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void ResourcesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This())) {
        return;
      }

      Application *wrapper = Application::Unwrap<Application>(info.This());

      try  {
        ::Windows::UI::Xaml::ResourceDictionary^ result = wrapper->_instance->Resources;
        info.GetReturnValue().Set(WrapResourceDictionary(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ResourcesSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ResourceDictionary^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This())) {
        return;
      }

      Application *wrapper = Application::Unwrap<Application>(info.This());

      try {

        ::Windows::UI::Xaml::ResourceDictionary^ winRtValue = dynamic_cast<::Windows::UI::Xaml::ResourceDictionary^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Resources = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void RequestedThemeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This())) {
        return;
      }

      Application *wrapper = Application::Unwrap<Application>(info.This());

      try  {
        ::Windows::UI::Xaml::ApplicationTheme result = wrapper->_instance->RequestedTheme;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RequestedThemeSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This())) {
        return;
      }

      Application *wrapper = Application::Unwrap<Application>(info.This());

      try {

        ::Windows::UI::Xaml::ApplicationTheme winRtValue = static_cast<::Windows::UI::Xaml::ApplicationTheme>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->RequestedTheme = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void DebugSettingsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This())) {
        return;
      }

      Application *wrapper = Application::Unwrap<Application>(info.This());

      try  {
        ::Windows::UI::Xaml::DebugSettings^ result = wrapper->_instance->DebugSettings;
        info.GetReturnValue().Set(WrapDebugSettings(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RequiresPointerModeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This())) {
        return;
      }

      Application *wrapper = Application::Unwrap<Application>(info.This());

      try  {
        ::Windows::UI::Xaml::ApplicationRequiresPointerMode result = wrapper->_instance->RequiresPointerMode;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RequiresPointerModeSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This())) {
        return;
      }

      Application *wrapper = Application::Unwrap<Application>(info.This());

      try {

        ::Windows::UI::Xaml::ApplicationRequiresPointerMode winRtValue = static_cast<::Windows::UI::Xaml::ApplicationRequiresPointerMode>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->RequiresPointerMode = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void FocusVisualKindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This())) {
        return;
      }

      Application *wrapper = Application::Unwrap<Application>(info.This());

      try  {
        ::Windows::UI::Xaml::FocusVisualKind result = wrapper->_instance->FocusVisualKind;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void FocusVisualKindSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This())) {
        return;
      }

      Application *wrapper = Application::Unwrap<Application>(info.This());

      try {

        ::Windows::UI::Xaml::FocusVisualKind winRtValue = static_cast<::Windows::UI::Xaml::FocusVisualKind>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->FocusVisualKind = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void HighContrastAdjustmentGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This())) {
        return;
      }

      Application *wrapper = Application::Unwrap<Application>(info.This());

      try  {
        ::Windows::UI::Xaml::ApplicationHighContrastAdjustment result = wrapper->_instance->HighContrastAdjustment;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void HighContrastAdjustmentSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This())) {
        return;
      }

      Application *wrapper = Application::Unwrap<Application>(info.This());

      try {

        ::Windows::UI::Xaml::ApplicationHighContrastAdjustment winRtValue = static_cast<::Windows::UI::Xaml::ApplicationHighContrastAdjustment>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->HighContrastAdjustment = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      


    static void CurrentGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::Application^ result = ::Windows::UI::Xaml::Application::Current;
        info.GetReturnValue().Set(WrapApplication(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void AddListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"resuming", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        Application *wrapper = Application::Unwrap<Application>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->Resuming::add(
            ref new ::Windows::Foundation::EventHandler<::Platform::Object^>(
            [callbackObjPtr](::Platform::Object^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"suspending", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        Application *wrapper = Application::Unwrap<Application>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->Suspending::add(
            ref new ::Windows::UI::Xaml::SuspendingEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::ApplicationModel::SuspendingEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "SuspendingEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"unhandledException", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        Application *wrapper = Application::Unwrap<Application>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->UnhandledException::add(
            ref new ::Windows::UI::Xaml::UnhandledExceptionEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::UnhandledExceptionEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = WrapUnhandledExceptionEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"enteredBackground", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        Application *wrapper = Application::Unwrap<Application>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->EnteredBackground::add(
            ref new ::Windows::UI::Xaml::EnteredBackgroundEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::ApplicationModel::EnteredBackgroundEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "EnteredBackgroundEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"leavingBackground", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        Application *wrapper = Application::Unwrap<Application>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->LeavingBackground::add(
            ref new ::Windows::UI::Xaml::LeavingBackgroundEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::ApplicationModel::LeavingBackgroundEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "LeavingBackgroundEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
 else  {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Value> tokenMapVal = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());
      Local<Object> tokenMap;

      if (tokenMapVal.IsEmpty() || Nan::Equals(tokenMapVal, Undefined()).FromMaybe(false)) {
        tokenMap = Nan::New<Object>();
        NodeRT::Utils::SetHiddenValueWithObject(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked(), tokenMap);
      } else {
        tokenMap = Nan::To<Object>(tokenMapVal).ToLocalChecked();
      }

      Nan::Set(tokenMap, info[0], CreateOpaqueWrapper(::Windows::Foundation::PropertyValue::CreateInt64(registrationToken.Value)));
    }

    static void RemoveListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected a string and a callback")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      if ((!NodeRT::Utils::CaseInsenstiveEquals(L"resuming", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"suspending", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"unhandledException", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"enteredBackground", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"leavingBackground", str))) {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Function> callback = info[1].As<Function>();
      Local<Value> tokenMap = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());

      if (tokenMap.IsEmpty() || Nan::Equals(tokenMap, Undefined()).FromMaybe(false)) {
        return;
      }

      Local<Value> opaqueWrapperObj =  Nan::Get(Nan::To<Object>(tokenMap).ToLocalChecked(), info[0]).ToLocalChecked();

      if (opaqueWrapperObj.IsEmpty() || Nan::Equals(opaqueWrapperObj,Undefined()).FromMaybe(false)) {
        return;
      }

      OpaqueWrapper *opaqueWrapper = OpaqueWrapper::Unwrap<OpaqueWrapper>(opaqueWrapperObj.As<Object>());

      long long tokenValue = (long long) opaqueWrapper->GetObjectInstance();
      ::Windows::Foundation::EventRegistrationToken registrationToken;
      registrationToken.Value = tokenValue;

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"resuming", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          Application *wrapper = Application::Unwrap<Application>(info.This());
          wrapper->_instance->Resuming::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"suspending", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          Application *wrapper = Application::Unwrap<Application>(info.This());
          wrapper->_instance->Suspending::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"unhandledException", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          Application *wrapper = Application::Unwrap<Application>(info.This());
          wrapper->_instance->UnhandledException::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"enteredBackground", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          Application *wrapper = Application::Unwrap<Application>(info.This());
          wrapper->_instance->EnteredBackground::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"leavingBackground", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Application^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          Application *wrapper = Application::Unwrap<Application>(info.This());
          wrapper->_instance->LeavingBackground::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

      Nan::Delete(Nan::To<Object>(tokenMap).ToLocalChecked(), Nan::To<String>(info[0]).ToLocalChecked());
    }
    private:
      ::Windows::UI::Xaml::Application^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapApplication(::Windows::UI::Xaml::Application^ wintRtInstance);
      friend ::Windows::UI::Xaml::Application^ UnwrapApplication(Local<Value> value);
  };

  Persistent<FunctionTemplate> Application::s_constructorTemplate;

  v8::Local<v8::Value> WrapApplication(::Windows::UI::Xaml::Application^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(Application::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::Application^ UnwrapApplication(Local<Value> value) {
     return Application::Unwrap<Application>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitApplication(Local<Object> exports) {
    Application::Init(exports);
  }

  class ApplicationInitializationCallbackParams : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("ApplicationInitializationCallbackParams").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);






        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ApplicationInitializationCallbackParams").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ApplicationInitializationCallbackParams(::Windows::UI::Xaml::ApplicationInitializationCallbackParams^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::ApplicationInitializationCallbackParams^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ApplicationInitializationCallbackParams^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::ApplicationInitializationCallbackParams^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      ApplicationInitializationCallbackParams *wrapperInstance = new ApplicationInitializationCallbackParams(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ApplicationInitializationCallbackParams^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::ApplicationInitializationCallbackParams^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::ApplicationInitializationCallbackParams^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapApplicationInitializationCallbackParams(winRtInstance));
    }







    private:
      ::Windows::UI::Xaml::ApplicationInitializationCallbackParams^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapApplicationInitializationCallbackParams(::Windows::UI::Xaml::ApplicationInitializationCallbackParams^ wintRtInstance);
      friend ::Windows::UI::Xaml::ApplicationInitializationCallbackParams^ UnwrapApplicationInitializationCallbackParams(Local<Value> value);
  };

  Persistent<FunctionTemplate> ApplicationInitializationCallbackParams::s_constructorTemplate;

  v8::Local<v8::Value> WrapApplicationInitializationCallbackParams(::Windows::UI::Xaml::ApplicationInitializationCallbackParams^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(ApplicationInitializationCallbackParams::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::ApplicationInitializationCallbackParams^ UnwrapApplicationInitializationCallbackParams(Local<Value> value) {
     return ApplicationInitializationCallbackParams::Unwrap<ApplicationInitializationCallbackParams>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitApplicationInitializationCallbackParams(Local<Object> exports) {
    ApplicationInitializationCallbackParams::Init(exports);
  }

  class BindingFailedEventArgs : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("BindingFailedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("message").ToLocalChecked(), MessageGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("BindingFailedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      BindingFailedEventArgs(::Windows::UI::Xaml::BindingFailedEventArgs^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::BindingFailedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BindingFailedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::BindingFailedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      BindingFailedEventArgs *wrapperInstance = new BindingFailedEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BindingFailedEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::BindingFailedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::BindingFailedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapBindingFailedEventArgs(winRtInstance));
    }





    static void MessageGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BindingFailedEventArgs^>(info.This())) {
        return;
      }

      BindingFailedEventArgs *wrapper = BindingFailedEventArgs::Unwrap<BindingFailedEventArgs>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Message;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::BindingFailedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapBindingFailedEventArgs(::Windows::UI::Xaml::BindingFailedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Xaml::BindingFailedEventArgs^ UnwrapBindingFailedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> BindingFailedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapBindingFailedEventArgs(::Windows::UI::Xaml::BindingFailedEventArgs^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(BindingFailedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::BindingFailedEventArgs^ UnwrapBindingFailedEventArgs(Local<Value> value) {
     return BindingFailedEventArgs::Unwrap<BindingFailedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitBindingFailedEventArgs(Local<Object> exports) {
    BindingFailedEventArgs::Init(exports);
  }

  class BringIntoViewOptions : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("BringIntoViewOptions").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("targetRect").ToLocalChecked(), TargetRectGetter, TargetRectSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("animationDesired").ToLocalChecked(), AnimationDesiredGetter, AnimationDesiredSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("verticalOffset").ToLocalChecked(), VerticalOffsetGetter, VerticalOffsetSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("verticalAlignmentRatio").ToLocalChecked(), VerticalAlignmentRatioGetter, VerticalAlignmentRatioSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("horizontalOffset").ToLocalChecked(), HorizontalOffsetGetter, HorizontalOffsetSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("horizontalAlignmentRatio").ToLocalChecked(), HorizontalAlignmentRatioGetter, HorizontalAlignmentRatioSetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("BringIntoViewOptions").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      BringIntoViewOptions(::Windows::UI::Xaml::BringIntoViewOptions^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::BringIntoViewOptions^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewOptions^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::BringIntoViewOptions^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::BringIntoViewOptions();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      BringIntoViewOptions *wrapperInstance = new BringIntoViewOptions(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewOptions^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::BringIntoViewOptions^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::BringIntoViewOptions^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapBringIntoViewOptions(winRtInstance));
    }





    static void TargetRectGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewOptions^>(info.This())) {
        return;
      }

      BringIntoViewOptions *wrapper = BringIntoViewOptions::Unwrap<BringIntoViewOptions>(info.This());

      try  {
        ::Platform::IBox<::Windows::Foundation::Rect>^ result = wrapper->_instance->TargetRect;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::RectToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TargetRectSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsRect(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewOptions^>(info.This())) {
        return;
      }

      BringIntoViewOptions *wrapper = BringIntoViewOptions::Unwrap<BringIntoViewOptions>(info.This());

      try {

        ::Platform::IBox<::Windows::Foundation::Rect>^ winRtValue = ref new ::Platform::Box<::Windows::Foundation::Rect>(NodeRT::Utils::RectFromJs(value));

        wrapper->_instance->TargetRect = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void AnimationDesiredGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewOptions^>(info.This())) {
        return;
      }

      BringIntoViewOptions *wrapper = BringIntoViewOptions::Unwrap<BringIntoViewOptions>(info.This());

      try  {
        bool result = wrapper->_instance->AnimationDesired;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AnimationDesiredSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewOptions^>(info.This())) {
        return;
      }

      BringIntoViewOptions *wrapper = BringIntoViewOptions::Unwrap<BringIntoViewOptions>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->AnimationDesired = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void VerticalOffsetGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewOptions^>(info.This())) {
        return;
      }

      BringIntoViewOptions *wrapper = BringIntoViewOptions::Unwrap<BringIntoViewOptions>(info.This());

      try  {
        double result = wrapper->_instance->VerticalOffset;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VerticalOffsetSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewOptions^>(info.This())) {
        return;
      }

      BringIntoViewOptions *wrapper = BringIntoViewOptions::Unwrap<BringIntoViewOptions>(info.This());

      try {

        double winRtValue = Nan::To<double>(value).FromMaybe(0.0);

        wrapper->_instance->VerticalOffset = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void VerticalAlignmentRatioGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewOptions^>(info.This())) {
        return;
      }

      BringIntoViewOptions *wrapper = BringIntoViewOptions::Unwrap<BringIntoViewOptions>(info.This());

      try  {
        double result = wrapper->_instance->VerticalAlignmentRatio;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VerticalAlignmentRatioSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewOptions^>(info.This())) {
        return;
      }

      BringIntoViewOptions *wrapper = BringIntoViewOptions::Unwrap<BringIntoViewOptions>(info.This());

      try {

        double winRtValue = Nan::To<double>(value).FromMaybe(0.0);

        wrapper->_instance->VerticalAlignmentRatio = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void HorizontalOffsetGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewOptions^>(info.This())) {
        return;
      }

      BringIntoViewOptions *wrapper = BringIntoViewOptions::Unwrap<BringIntoViewOptions>(info.This());

      try  {
        double result = wrapper->_instance->HorizontalOffset;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void HorizontalOffsetSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewOptions^>(info.This())) {
        return;
      }

      BringIntoViewOptions *wrapper = BringIntoViewOptions::Unwrap<BringIntoViewOptions>(info.This());

      try {

        double winRtValue = Nan::To<double>(value).FromMaybe(0.0);

        wrapper->_instance->HorizontalOffset = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void HorizontalAlignmentRatioGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewOptions^>(info.This())) {
        return;
      }

      BringIntoViewOptions *wrapper = BringIntoViewOptions::Unwrap<BringIntoViewOptions>(info.This());

      try  {
        double result = wrapper->_instance->HorizontalAlignmentRatio;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void HorizontalAlignmentRatioSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewOptions^>(info.This())) {
        return;
      }

      BringIntoViewOptions *wrapper = BringIntoViewOptions::Unwrap<BringIntoViewOptions>(info.This());

      try {

        double winRtValue = Nan::To<double>(value).FromMaybe(0.0);

        wrapper->_instance->HorizontalAlignmentRatio = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      


    private:
      ::Windows::UI::Xaml::BringIntoViewOptions^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapBringIntoViewOptions(::Windows::UI::Xaml::BringIntoViewOptions^ wintRtInstance);
      friend ::Windows::UI::Xaml::BringIntoViewOptions^ UnwrapBringIntoViewOptions(Local<Value> value);
  };

  Persistent<FunctionTemplate> BringIntoViewOptions::s_constructorTemplate;

  v8::Local<v8::Value> WrapBringIntoViewOptions(::Windows::UI::Xaml::BringIntoViewOptions^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(BringIntoViewOptions::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::BringIntoViewOptions^ UnwrapBringIntoViewOptions(Local<Value> value) {
     return BringIntoViewOptions::Unwrap<BringIntoViewOptions>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitBringIntoViewOptions(Local<Object> exports) {
    BringIntoViewOptions::Init(exports);
  }

  class RoutedEventArgs : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("RoutedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("originalSource").ToLocalChecked(), OriginalSourceGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("RoutedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      RoutedEventArgs(::Windows::UI::Xaml::RoutedEventArgs^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::RoutedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::RoutedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::RoutedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::RoutedEventArgs();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      RoutedEventArgs *wrapperInstance = new RoutedEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::RoutedEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::RoutedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::RoutedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapRoutedEventArgs(winRtInstance));
    }





    static void OriginalSourceGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::RoutedEventArgs^>(info.This())) {
        return;
      }

      RoutedEventArgs *wrapper = RoutedEventArgs::Unwrap<RoutedEventArgs>(info.This());

      try  {
        ::Platform::Object^ result = wrapper->_instance->OriginalSource;
        info.GetReturnValue().Set(CreateOpaqueWrapper(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::RoutedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapRoutedEventArgs(::Windows::UI::Xaml::RoutedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Xaml::RoutedEventArgs^ UnwrapRoutedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> RoutedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapRoutedEventArgs(::Windows::UI::Xaml::RoutedEventArgs^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(RoutedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::RoutedEventArgs^ UnwrapRoutedEventArgs(Local<Value> value) {
     return RoutedEventArgs::Unwrap<RoutedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitRoutedEventArgs(Local<Object> exports) {
    RoutedEventArgs::Init(exports);
  }

  class BringIntoViewRequestedEventArgs : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("BringIntoViewRequestedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("verticalOffset").ToLocalChecked(), VerticalOffsetGetter, VerticalOffsetSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("targetRect").ToLocalChecked(), TargetRectGetter, TargetRectSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("targetElement").ToLocalChecked(), TargetElementGetter, TargetElementSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("horizontalOffset").ToLocalChecked(), HorizontalOffsetGetter, HorizontalOffsetSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("handled").ToLocalChecked(), HandledGetter, HandledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("animationDesired").ToLocalChecked(), AnimationDesiredGetter, AnimationDesiredSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("horizontalAlignmentRatio").ToLocalChecked(), HorizontalAlignmentRatioGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("verticalAlignmentRatio").ToLocalChecked(), VerticalAlignmentRatioGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("originalSource").ToLocalChecked(), OriginalSourceGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("BringIntoViewRequestedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      BringIntoViewRequestedEventArgs(::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      BringIntoViewRequestedEventArgs *wrapperInstance = new BringIntoViewRequestedEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapBringIntoViewRequestedEventArgs(winRtInstance));
    }





    static void VerticalOffsetGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^>(info.This())) {
        return;
      }

      BringIntoViewRequestedEventArgs *wrapper = BringIntoViewRequestedEventArgs::Unwrap<BringIntoViewRequestedEventArgs>(info.This());

      try  {
        double result = wrapper->_instance->VerticalOffset;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VerticalOffsetSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^>(info.This())) {
        return;
      }

      BringIntoViewRequestedEventArgs *wrapper = BringIntoViewRequestedEventArgs::Unwrap<BringIntoViewRequestedEventArgs>(info.This());

      try {

        double winRtValue = Nan::To<double>(value).FromMaybe(0.0);

        wrapper->_instance->VerticalOffset = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void TargetRectGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^>(info.This())) {
        return;
      }

      BringIntoViewRequestedEventArgs *wrapper = BringIntoViewRequestedEventArgs::Unwrap<BringIntoViewRequestedEventArgs>(info.This());

      try  {
        ::Windows::Foundation::Rect result = wrapper->_instance->TargetRect;
        info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TargetRectSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsRect(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^>(info.This())) {
        return;
      }

      BringIntoViewRequestedEventArgs *wrapper = BringIntoViewRequestedEventArgs::Unwrap<BringIntoViewRequestedEventArgs>(info.This());

      try {

        ::Windows::Foundation::Rect winRtValue = NodeRT::Utils::RectFromJs(value);

        wrapper->_instance->TargetRect = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void TargetElementGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^>(info.This())) {
        return;
      }

      BringIntoViewRequestedEventArgs *wrapper = BringIntoViewRequestedEventArgs::Unwrap<BringIntoViewRequestedEventArgs>(info.This());

      try  {
        ::Windows::UI::Xaml::UIElement^ result = wrapper->_instance->TargetElement;
        info.GetReturnValue().Set(WrapUIElement(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TargetElementSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^>(info.This())) {
        return;
      }

      BringIntoViewRequestedEventArgs *wrapper = BringIntoViewRequestedEventArgs::Unwrap<BringIntoViewRequestedEventArgs>(info.This());

      try {

        ::Windows::UI::Xaml::UIElement^ winRtValue = dynamic_cast<::Windows::UI::Xaml::UIElement^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->TargetElement = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void HorizontalOffsetGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^>(info.This())) {
        return;
      }

      BringIntoViewRequestedEventArgs *wrapper = BringIntoViewRequestedEventArgs::Unwrap<BringIntoViewRequestedEventArgs>(info.This());

      try  {
        double result = wrapper->_instance->HorizontalOffset;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void HorizontalOffsetSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^>(info.This())) {
        return;
      }

      BringIntoViewRequestedEventArgs *wrapper = BringIntoViewRequestedEventArgs::Unwrap<BringIntoViewRequestedEventArgs>(info.This());

      try {

        double winRtValue = Nan::To<double>(value).FromMaybe(0.0);

        wrapper->_instance->HorizontalOffset = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void HandledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^>(info.This())) {
        return;
      }

      BringIntoViewRequestedEventArgs *wrapper = BringIntoViewRequestedEventArgs::Unwrap<BringIntoViewRequestedEventArgs>(info.This());

      try  {
        bool result = wrapper->_instance->Handled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void HandledSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^>(info.This())) {
        return;
      }

      BringIntoViewRequestedEventArgs *wrapper = BringIntoViewRequestedEventArgs::Unwrap<BringIntoViewRequestedEventArgs>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->Handled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void AnimationDesiredGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^>(info.This())) {
        return;
      }

      BringIntoViewRequestedEventArgs *wrapper = BringIntoViewRequestedEventArgs::Unwrap<BringIntoViewRequestedEventArgs>(info.This());

      try  {
        bool result = wrapper->_instance->AnimationDesired;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AnimationDesiredSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^>(info.This())) {
        return;
      }

      BringIntoViewRequestedEventArgs *wrapper = BringIntoViewRequestedEventArgs::Unwrap<BringIntoViewRequestedEventArgs>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->AnimationDesired = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void HorizontalAlignmentRatioGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^>(info.This())) {
        return;
      }

      BringIntoViewRequestedEventArgs *wrapper = BringIntoViewRequestedEventArgs::Unwrap<BringIntoViewRequestedEventArgs>(info.This());

      try  {
        double result = wrapper->_instance->HorizontalAlignmentRatio;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VerticalAlignmentRatioGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^>(info.This())) {
        return;
      }

      BringIntoViewRequestedEventArgs *wrapper = BringIntoViewRequestedEventArgs::Unwrap<BringIntoViewRequestedEventArgs>(info.This());

      try  {
        double result = wrapper->_instance->VerticalAlignmentRatio;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void OriginalSourceGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::RoutedEventArgs^>(info.This())) {
        return;
      }

      RoutedEventArgs *wrapper = RoutedEventArgs::Unwrap<RoutedEventArgs>(info.This());

      try  {
        ::Platform::Object^ result = wrapper->_instance->OriginalSource;
        info.GetReturnValue().Set(CreateOpaqueWrapper(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapBringIntoViewRequestedEventArgs(::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^ UnwrapBringIntoViewRequestedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> BringIntoViewRequestedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapBringIntoViewRequestedEventArgs(::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(BringIntoViewRequestedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^ UnwrapBringIntoViewRequestedEventArgs(Local<Value> value) {
     return BringIntoViewRequestedEventArgs::Unwrap<BringIntoViewRequestedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitBringIntoViewRequestedEventArgs(Local<Object> exports) {
    BringIntoViewRequestedEventArgs::Init(exports);
  }

  class BrushTransition : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("BrushTransition").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("duration").ToLocalChecked(), DurationGetter, DurationSetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("BrushTransition").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      BrushTransition(::Windows::UI::Xaml::BrushTransition^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::BrushTransition^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BrushTransition^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::BrushTransition^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::BrushTransition();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      BrushTransition *wrapperInstance = new BrushTransition(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BrushTransition^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::BrushTransition^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::BrushTransition^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapBrushTransition(winRtInstance));
    }





    static void DurationGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BrushTransition^>(info.This())) {
        return;
      }

      BrushTransition *wrapper = BrushTransition::Unwrap<BrushTransition>(info.This());

      try  {
        ::Windows::Foundation::TimeSpan result = wrapper->_instance->Duration;
        info.GetReturnValue().Set(Nan::New<Number>(result.Duration/10000.0));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DurationSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BrushTransition^>(info.This())) {
        return;
      }

      BrushTransition *wrapper = BrushTransition::Unwrap<BrushTransition>(info.This());

      try {

        ::Windows::Foundation::TimeSpan winRtValue = NodeRT::Utils::TimeSpanFromMilli(Nan::To<int64_t>(value).FromMaybe(0));

        wrapper->_instance->Duration = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      


    private:
      ::Windows::UI::Xaml::BrushTransition^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapBrushTransition(::Windows::UI::Xaml::BrushTransition^ wintRtInstance);
      friend ::Windows::UI::Xaml::BrushTransition^ UnwrapBrushTransition(Local<Value> value);
  };

  Persistent<FunctionTemplate> BrushTransition::s_constructorTemplate;

  v8::Local<v8::Value> WrapBrushTransition(::Windows::UI::Xaml::BrushTransition^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(BrushTransition::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::BrushTransition^ UnwrapBrushTransition(Local<Value> value) {
     return BrushTransition::Unwrap<BrushTransition>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitBrushTransition(Local<Object> exports) {
    BrushTransition::Init(exports);
  }

  class ResourceDictionary : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("ResourceDictionary").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "lookup", Lookup);
            Nan::SetPrototypeMethod(localRef, "hasKey", HasKey);
            Nan::SetPrototypeMethod(localRef, "getView", GetView);
            Nan::SetPrototypeMethod(localRef, "insert", Insert);
            Nan::SetPrototypeMethod(localRef, "remove", Remove);
            Nan::SetPrototypeMethod(localRef, "clear", Clear);
            Nan::SetPrototypeMethod(localRef, "first", First);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("source").ToLocalChecked(), SourceGetter, SourceSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("mergedDictionaries").ToLocalChecked(), MergedDictionariesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("themeDictionaries").ToLocalChecked(), ThemeDictionariesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ResourceDictionary").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ResourceDictionary(::Windows::UI::Xaml::ResourceDictionary^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::ResourceDictionary^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ResourceDictionary^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::ResourceDictionary^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::ResourceDictionary();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      ResourceDictionary *wrapperInstance = new ResourceDictionary(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ResourceDictionary^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::ResourceDictionary^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::ResourceDictionary^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapResourceDictionary(winRtInstance));
    }


    static void Lookup(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ResourceDictionary^>(info.This())) {
        return;
      }

      ResourceDictionary *wrapper = ResourceDictionary::Unwrap<ResourceDictionary>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[0]))
      {
        try
        {
          ::Platform::Object^ arg0 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Platform::Object^ result;
          result = wrapper->_instance->Lookup(arg0);
          info.GetReturnValue().Set(CreateOpaqueWrapper(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void HasKey(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ResourceDictionary^>(info.This())) {
        return;
      }

      ResourceDictionary *wrapper = ResourceDictionary::Unwrap<ResourceDictionary>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[0]))
      {
        try
        {
          ::Platform::Object^ arg0 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          bool result;
          result = wrapper->_instance->HasKey(arg0);
          info.GetReturnValue().Set(Nan::New<Boolean>(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetView(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ResourceDictionary^>(info.This())) {
        return;
      }

      ResourceDictionary *wrapper = ResourceDictionary::Unwrap<ResourceDictionary>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IMapView<::Platform::Object^, ::Platform::Object^>^ result;
          result = wrapper->_instance->GetView();
          info.GetReturnValue().Set(NodeRT::Collections::MapViewWrapper<::Platform::Object^,::Platform::Object^>::CreateMapViewWrapper(result, 
            [](::Platform::Object^ val) -> Local<Value> {
              return CreateOpaqueWrapper(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(value);
            },
            [](Local<Value> value) -> ::Platform::Object^ {
              return dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(value));
            },
            [](::Platform::Object^ val) -> Local<Value> {
              return CreateOpaqueWrapper(val);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Insert(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ResourceDictionary^>(info.This())) {
        return;
      }

      ResourceDictionary *wrapper = ResourceDictionary::Unwrap<ResourceDictionary>(info.This());

      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[1]))
      {
        try
        {
          ::Platform::Object^ arg0 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Platform::Object^ arg1 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          bool result;
          result = wrapper->_instance->Insert(arg0, arg1);
          info.GetReturnValue().Set(Nan::New<Boolean>(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Remove(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ResourceDictionary^>(info.This())) {
        return;
      }

      ResourceDictionary *wrapper = ResourceDictionary::Unwrap<ResourceDictionary>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[0]))
      {
        try
        {
          ::Platform::Object^ arg0 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          wrapper->_instance->Remove(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Clear(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ResourceDictionary^>(info.This())) {
        return;
      }

      ResourceDictionary *wrapper = ResourceDictionary::Unwrap<ResourceDictionary>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->Clear();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void First(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ResourceDictionary^>(info.This())) {
        return;
      }

      ResourceDictionary *wrapper = ResourceDictionary::Unwrap<ResourceDictionary>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IIterator<::Windows::Foundation::Collections::IKeyValuePair<::Platform::Object^, ::Platform::Object^>^>^ result;
          result = wrapper->_instance->First();
          info.GetReturnValue().Set(NodeRT::Collections::IteratorWrapper<::Windows::Foundation::Collections::IKeyValuePair<::Platform::Object^, ::Platform::Object^>^>::CreateIteratorWrapper(result, 
            [](::Windows::Foundation::Collections::IKeyValuePair<::Platform::Object^, ::Platform::Object^>^ val) -> Local<Value> {
              return NodeRT::Collections::KeyValuePairWrapper<::Platform::Object^,::Platform::Object^>::CreateKeyValuePairWrapper(val, 
            [](::Platform::Object^ val) -> Local<Value> {
              return CreateOpaqueWrapper(val);
            },
            [](::Platform::Object^ val) -> Local<Value> {
              return CreateOpaqueWrapper(val);
            }
          );
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    static void SourceGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ResourceDictionary^>(info.This())) {
        return;
      }

      ResourceDictionary *wrapper = ResourceDictionary::Unwrap<ResourceDictionary>(info.This());

      try  {
        ::Windows::Foundation::Uri^ result = wrapper->_instance->Source;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "Uri", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SourceSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ResourceDictionary^>(info.This())) {
        return;
      }

      ResourceDictionary *wrapper = ResourceDictionary::Unwrap<ResourceDictionary>(info.This());

      try {

        ::Windows::Foundation::Uri^ winRtValue = dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Source = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void MergedDictionariesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ResourceDictionary^>(info.This())) {
        return;
      }

      ResourceDictionary *wrapper = ResourceDictionary::Unwrap<ResourceDictionary>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::UI::Xaml::ResourceDictionary^>^ result = wrapper->_instance->MergedDictionaries;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::UI::Xaml::ResourceDictionary^>::CreateVectorWrapper(result, 
            [](::Windows::UI::Xaml::ResourceDictionary^ val) -> Local<Value> {
              return WrapResourceDictionary(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ResourceDictionary^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Xaml::ResourceDictionary^ {
              return UnwrapResourceDictionary(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ThemeDictionariesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ResourceDictionary^>(info.This())) {
        return;
      }

      ResourceDictionary *wrapper = ResourceDictionary::Unwrap<ResourceDictionary>(info.This());

      try  {
        ::Windows::Foundation::Collections::IMap<::Platform::Object^, ::Platform::Object^>^ result = wrapper->_instance->ThemeDictionaries;
        info.GetReturnValue().Set(NodeRT::Collections::MapWrapper<::Platform::Object^,::Platform::Object^>::CreateMapWrapper(result, 
            [](::Platform::Object^ val) -> Local<Value> {
              return CreateOpaqueWrapper(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(value);
            },
            [](Local<Value> value) -> ::Platform::Object^ {
              return dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(value));
            },
            [](::Platform::Object^ val) -> Local<Value> {
              return CreateOpaqueWrapper(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(value);
            },
            [](Local<Value> value) -> ::Platform::Object^ {
              return dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DispatcherGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      try  {
        ::Windows::UI::Core::CoreDispatcher^ result = wrapper->_instance->Dispatcher;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "CoreDispatcher", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::ResourceDictionary^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapResourceDictionary(::Windows::UI::Xaml::ResourceDictionary^ wintRtInstance);
      friend ::Windows::UI::Xaml::ResourceDictionary^ UnwrapResourceDictionary(Local<Value> value);
  };

  Persistent<FunctionTemplate> ResourceDictionary::s_constructorTemplate;

  v8::Local<v8::Value> WrapResourceDictionary(::Windows::UI::Xaml::ResourceDictionary^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(ResourceDictionary::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::ResourceDictionary^ UnwrapResourceDictionary(Local<Value> value) {
     return ResourceDictionary::Unwrap<ResourceDictionary>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitResourceDictionary(Local<Object> exports) {
    ResourceDictionary::Init(exports);
  }

  class ColorPaletteResources : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("ColorPaletteResources").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("listMedium").ToLocalChecked(), ListMediumGetter, ListMediumSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("listLow").ToLocalChecked(), ListLowGetter, ListLowSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("errorText").ToLocalChecked(), ErrorTextGetter, ErrorTextSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("chromeWhite").ToLocalChecked(), ChromeWhiteGetter, ChromeWhiteSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("chromeMediumLow").ToLocalChecked(), ChromeMediumLowGetter, ChromeMediumLowSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("chromeMedium").ToLocalChecked(), ChromeMediumGetter, ChromeMediumSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("chromeLow").ToLocalChecked(), ChromeLowGetter, ChromeLowSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("chromeHigh").ToLocalChecked(), ChromeHighGetter, ChromeHighSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("chromeGray").ToLocalChecked(), ChromeGrayGetter, ChromeGraySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("chromeDisabledLow").ToLocalChecked(), ChromeDisabledLowGetter, ChromeDisabledLowSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("chromeDisabledHigh").ToLocalChecked(), ChromeDisabledHighGetter, ChromeDisabledHighSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("chromeBlackMediumLow").ToLocalChecked(), ChromeBlackMediumLowGetter, ChromeBlackMediumLowSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("chromeBlackMedium").ToLocalChecked(), ChromeBlackMediumGetter, ChromeBlackMediumSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("chromeBlackLow").ToLocalChecked(), ChromeBlackLowGetter, ChromeBlackLowSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("chromeBlackHigh").ToLocalChecked(), ChromeBlackHighGetter, ChromeBlackHighSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("chromeAltLow").ToLocalChecked(), ChromeAltLowGetter, ChromeAltLowSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("baseMediumLow").ToLocalChecked(), BaseMediumLowGetter, BaseMediumLowSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("baseMediumHigh").ToLocalChecked(), BaseMediumHighGetter, BaseMediumHighSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("baseMedium").ToLocalChecked(), BaseMediumGetter, BaseMediumSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("baseLow").ToLocalChecked(), BaseLowGetter, BaseLowSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("baseHigh").ToLocalChecked(), BaseHighGetter, BaseHighSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("altMediumLow").ToLocalChecked(), AltMediumLowGetter, AltMediumLowSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("altMediumHigh").ToLocalChecked(), AltMediumHighGetter, AltMediumHighSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("altMedium").ToLocalChecked(), AltMediumGetter, AltMediumSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("altLow").ToLocalChecked(), AltLowGetter, AltLowSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("altHigh").ToLocalChecked(), AltHighGetter, AltHighSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("accent").ToLocalChecked(), AccentGetter, AccentSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("source").ToLocalChecked(), SourceGetter, SourceSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("mergedDictionaries").ToLocalChecked(), MergedDictionariesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("themeDictionaries").ToLocalChecked(), ThemeDictionariesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ColorPaletteResources").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ColorPaletteResources(::Windows::UI::Xaml::ColorPaletteResources^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::ColorPaletteResources^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::ColorPaletteResources^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::ColorPaletteResources();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      ColorPaletteResources *wrapperInstance = new ColorPaletteResources(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::ColorPaletteResources^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::ColorPaletteResources^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapColorPaletteResources(winRtInstance));
    }





    static void ListMediumGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->ListMedium;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ListMediumSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

        wrapper->_instance->ListMedium = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ListLowGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->ListLow;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ListLowSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

        wrapper->_instance->ListLow = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ErrorTextGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->ErrorText;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ErrorTextSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

        wrapper->_instance->ErrorText = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ChromeWhiteGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->ChromeWhite;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ChromeWhiteSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

        wrapper->_instance->ChromeWhite = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ChromeMediumLowGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->ChromeMediumLow;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ChromeMediumLowSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

        wrapper->_instance->ChromeMediumLow = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ChromeMediumGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->ChromeMedium;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ChromeMediumSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

        wrapper->_instance->ChromeMedium = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ChromeLowGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->ChromeLow;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ChromeLowSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

        wrapper->_instance->ChromeLow = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ChromeHighGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->ChromeHigh;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ChromeHighSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

        wrapper->_instance->ChromeHigh = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ChromeGrayGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->ChromeGray;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ChromeGraySetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

        wrapper->_instance->ChromeGray = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ChromeDisabledLowGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->ChromeDisabledLow;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ChromeDisabledLowSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

        wrapper->_instance->ChromeDisabledLow = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ChromeDisabledHighGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->ChromeDisabledHigh;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ChromeDisabledHighSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

        wrapper->_instance->ChromeDisabledHigh = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ChromeBlackMediumLowGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->ChromeBlackMediumLow;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ChromeBlackMediumLowSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

        wrapper->_instance->ChromeBlackMediumLow = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ChromeBlackMediumGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->ChromeBlackMedium;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ChromeBlackMediumSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

        wrapper->_instance->ChromeBlackMedium = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ChromeBlackLowGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->ChromeBlackLow;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ChromeBlackLowSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

        wrapper->_instance->ChromeBlackLow = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ChromeBlackHighGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->ChromeBlackHigh;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ChromeBlackHighSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

        wrapper->_instance->ChromeBlackHigh = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ChromeAltLowGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->ChromeAltLow;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ChromeAltLowSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

        wrapper->_instance->ChromeAltLow = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void BaseMediumLowGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->BaseMediumLow;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BaseMediumLowSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

        wrapper->_instance->BaseMediumLow = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void BaseMediumHighGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->BaseMediumHigh;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BaseMediumHighSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

        wrapper->_instance->BaseMediumHigh = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void BaseMediumGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->BaseMedium;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BaseMediumSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

        wrapper->_instance->BaseMedium = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void BaseLowGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->BaseLow;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BaseLowSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

        wrapper->_instance->BaseLow = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void BaseHighGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->BaseHigh;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BaseHighSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

        wrapper->_instance->BaseHigh = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void AltMediumLowGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->AltMediumLow;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AltMediumLowSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

        wrapper->_instance->AltMediumLow = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void AltMediumHighGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->AltMediumHigh;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AltMediumHighSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

        wrapper->_instance->AltMediumHigh = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void AltMediumGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->AltMedium;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AltMediumSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

        wrapper->_instance->AltMedium = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void AltLowGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->AltLow;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AltLowSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

        wrapper->_instance->AltLow = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void AltHighGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->AltHigh;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AltHighSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

        wrapper->_instance->AltHigh = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void AccentGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->Accent;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AccentSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ColorPaletteResources^>(info.This())) {
        return;
      }

      ColorPaletteResources *wrapper = ColorPaletteResources::Unwrap<ColorPaletteResources>(info.This());

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

        wrapper->_instance->Accent = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void SourceGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ResourceDictionary^>(info.This())) {
        return;
      }

      ResourceDictionary *wrapper = ResourceDictionary::Unwrap<ResourceDictionary>(info.This());

      try  {
        ::Windows::Foundation::Uri^ result = wrapper->_instance->Source;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "Uri", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SourceSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ResourceDictionary^>(info.This())) {
        return;
      }

      ResourceDictionary *wrapper = ResourceDictionary::Unwrap<ResourceDictionary>(info.This());

      try {

        ::Windows::Foundation::Uri^ winRtValue = dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Source = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void MergedDictionariesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ResourceDictionary^>(info.This())) {
        return;
      }

      ResourceDictionary *wrapper = ResourceDictionary::Unwrap<ResourceDictionary>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::UI::Xaml::ResourceDictionary^>^ result = wrapper->_instance->MergedDictionaries;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::UI::Xaml::ResourceDictionary^>::CreateVectorWrapper(result, 
            [](::Windows::UI::Xaml::ResourceDictionary^ val) -> Local<Value> {
              return WrapResourceDictionary(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ResourceDictionary^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Xaml::ResourceDictionary^ {
              return UnwrapResourceDictionary(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ThemeDictionariesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ResourceDictionary^>(info.This())) {
        return;
      }

      ResourceDictionary *wrapper = ResourceDictionary::Unwrap<ResourceDictionary>(info.This());

      try  {
        ::Windows::Foundation::Collections::IMap<::Platform::Object^, ::Platform::Object^>^ result = wrapper->_instance->ThemeDictionaries;
        info.GetReturnValue().Set(NodeRT::Collections::MapWrapper<::Platform::Object^,::Platform::Object^>::CreateMapWrapper(result, 
            [](::Platform::Object^ val) -> Local<Value> {
              return CreateOpaqueWrapper(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(value);
            },
            [](Local<Value> value) -> ::Platform::Object^ {
              return dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(value));
            },
            [](::Platform::Object^ val) -> Local<Value> {
              return CreateOpaqueWrapper(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(value);
            },
            [](Local<Value> value) -> ::Platform::Object^ {
              return dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DispatcherGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      try  {
        ::Windows::UI::Core::CoreDispatcher^ result = wrapper->_instance->Dispatcher;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "CoreDispatcher", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::ColorPaletteResources^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapColorPaletteResources(::Windows::UI::Xaml::ColorPaletteResources^ wintRtInstance);
      friend ::Windows::UI::Xaml::ColorPaletteResources^ UnwrapColorPaletteResources(Local<Value> value);
  };

  Persistent<FunctionTemplate> ColorPaletteResources::s_constructorTemplate;

  v8::Local<v8::Value> WrapColorPaletteResources(::Windows::UI::Xaml::ColorPaletteResources^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(ColorPaletteResources::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::ColorPaletteResources^ UnwrapColorPaletteResources(Local<Value> value) {
     return ColorPaletteResources::Unwrap<ColorPaletteResources>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitColorPaletteResources(Local<Object> exports) {
    ColorPaletteResources::Init(exports);
  }

  class UIElement : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("UIElement").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);

        Local<Function> func;
        Local<FunctionTemplate> funcTemplate;

          
            Nan::SetPrototypeMethod(localRef, "onCreateAutomationPeer", OnCreateAutomationPeer);
            Nan::SetPrototypeMethod(localRef, "onDisconnectVisualChildren", OnDisconnectVisualChildren);
            Nan::SetPrototypeMethod(localRef, "findSubElementsForTouchTargeting", FindSubElementsForTouchTargeting);
            Nan::SetPrototypeMethod(localRef, "getChildrenInTabFocusOrder", GetChildrenInTabFocusOrder);
            Nan::SetPrototypeMethod(localRef, "onProcessKeyboardAccelerators", OnProcessKeyboardAccelerators);
            Nan::SetPrototypeMethod(localRef, "onKeyboardAcceleratorInvoked", OnKeyboardAcceleratorInvoked);
            Nan::SetPrototypeMethod(localRef, "onBringIntoViewRequested", OnBringIntoViewRequested);
            Nan::SetPrototypeMethod(localRef, "populatePropertyInfoOverride", PopulatePropertyInfoOverride);
            Nan::SetPrototypeMethod(localRef, "populatePropertyInfo", PopulatePropertyInfo);
            Nan::SetPrototypeMethod(localRef, "startBringIntoView", StartBringIntoView);
            Nan::SetPrototypeMethod(localRef, "tryInvokeKeyboardAccelerator", TryInvokeKeyboardAccelerator);
            Nan::SetPrototypeMethod(localRef, "startAnimation", StartAnimation);
            Nan::SetPrototypeMethod(localRef, "stopAnimation", StopAnimation);
            Nan::SetPrototypeMethod(localRef, "measure", Measure);
            Nan::SetPrototypeMethod(localRef, "arrange", Arrange);
            Nan::SetPrototypeMethod(localRef, "capturePointer", CapturePointer);
            Nan::SetPrototypeMethod(localRef, "releasePointerCapture", ReleasePointerCapture);
            Nan::SetPrototypeMethod(localRef, "releasePointerCaptures", ReleasePointerCaptures);
            Nan::SetPrototypeMethod(localRef, "addHandler", AddHandler);
            Nan::SetPrototypeMethod(localRef, "removeHandler", RemoveHandler);
            Nan::SetPrototypeMethod(localRef, "transformToVisual", TransformToVisual);
            Nan::SetPrototypeMethod(localRef, "invalidateMeasure", InvalidateMeasure);
            Nan::SetPrototypeMethod(localRef, "invalidateArrange", InvalidateArrange);
            Nan::SetPrototypeMethod(localRef, "updateLayout", UpdateLayout);
            Nan::SetPrototypeMethod(localRef, "cancelDirectManipulations", CancelDirectManipulations);
          

          
            Nan::SetPrototypeMethod(localRef, "startDragAsync", StartDragAsync);
          

          
          Nan::SetPrototypeMethod(localRef,"addListener", AddListener);
          Nan::SetPrototypeMethod(localRef,"on", AddListener);
          Nan::SetPrototypeMethod(localRef,"removeListener", RemoveListener);
          Nan::SetPrototypeMethod(localRef, "off", RemoveListener);

          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("transitions").ToLocalChecked(), TransitionsGetter, TransitionsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("projection").ToLocalChecked(), ProjectionGetter, ProjectionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("renderTransformOrigin").ToLocalChecked(), RenderTransformOriginGetter, RenderTransformOriginSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("opacity").ToLocalChecked(), OpacityGetter, OpacitySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("manipulationMode").ToLocalChecked(), ManipulationModeGetter, ManipulationModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isTapEnabled").ToLocalChecked(), IsTapEnabledGetter, IsTapEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isRightTapEnabled").ToLocalChecked(), IsRightTapEnabledGetter, IsRightTapEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isHoldingEnabled").ToLocalChecked(), IsHoldingEnabledGetter, IsHoldingEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isHitTestVisible").ToLocalChecked(), IsHitTestVisibleGetter, IsHitTestVisibleSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isDoubleTapEnabled").ToLocalChecked(), IsDoubleTapEnabledGetter, IsDoubleTapEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("allowDrop").ToLocalChecked(), AllowDropGetter, AllowDropSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("clip").ToLocalChecked(), ClipGetter, ClipSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("cacheMode").ToLocalChecked(), CacheModeGetter, CacheModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("useLayoutRounding").ToLocalChecked(), UseLayoutRoundingGetter, UseLayoutRoundingSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("renderTransform").ToLocalChecked(), RenderTransformGetter, RenderTransformSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("visibility").ToLocalChecked(), VisibilityGetter, VisibilitySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("desiredSize").ToLocalChecked(), DesiredSizeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pointerCaptures").ToLocalChecked(), PointerCapturesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("renderSize").ToLocalChecked(), RenderSizeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("xamlRoot").ToLocalChecked(), XamlRootGetter, XamlRootSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("shadow").ToLocalChecked(), ShadowGetter, ShadowSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("actualOffset").ToLocalChecked(), ActualOffsetGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("actualSize").ToLocalChecked(), ActualSizeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("uIContext").ToLocalChecked(), UIContextGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("compositeMode").ToLocalChecked(), CompositeModeGetter, CompositeModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("transform3D").ToLocalChecked(), Transform3DGetter, Transform3DSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("canDrag").ToLocalChecked(), CanDragGetter, CanDragSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isAccessKeyScope").ToLocalChecked(), IsAccessKeyScopeGetter, IsAccessKeyScopeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("exitDisplayModeOnAccessKeyInvoked").ToLocalChecked(), ExitDisplayModeOnAccessKeyInvokedGetter, ExitDisplayModeOnAccessKeyInvokedSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("contextFlyout").ToLocalChecked(), ContextFlyoutGetter, ContextFlyoutSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("accessKeyScopeOwner").ToLocalChecked(), AccessKeyScopeOwnerGetter, AccessKeyScopeOwnerSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("accessKey").ToLocalChecked(), AccessKeyGetter, AccessKeySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("keyTipHorizontalOffset").ToLocalChecked(), KeyTipHorizontalOffsetGetter, KeyTipHorizontalOffsetSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("highContrastAdjustment").ToLocalChecked(), HighContrastAdjustmentGetter, HighContrastAdjustmentSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("xYFocusRightNavigationStrategy").ToLocalChecked(), XYFocusRightNavigationStrategyGetter, XYFocusRightNavigationStrategySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("xYFocusKeyboardNavigation").ToLocalChecked(), XYFocusKeyboardNavigationGetter, XYFocusKeyboardNavigationSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("xYFocusDownNavigationStrategy").ToLocalChecked(), XYFocusDownNavigationStrategyGetter, XYFocusDownNavigationStrategySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("tabFocusNavigation").ToLocalChecked(), TabFocusNavigationGetter, TabFocusNavigationSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("keyTipVerticalOffset").ToLocalChecked(), KeyTipVerticalOffsetGetter, KeyTipVerticalOffsetSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("xYFocusUpNavigationStrategy").ToLocalChecked(), XYFocusUpNavigationStrategyGetter, XYFocusUpNavigationStrategySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("keyTipPlacementMode").ToLocalChecked(), KeyTipPlacementModeGetter, KeyTipPlacementModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("xYFocusLeftNavigationStrategy").ToLocalChecked(), XYFocusLeftNavigationStrategyGetter, XYFocusLeftNavigationStrategySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("lights").ToLocalChecked(), LightsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("keyboardAccelerators").ToLocalChecked(), KeyboardAcceleratorsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("keyboardAcceleratorPlacementTarget").ToLocalChecked(), KeyboardAcceleratorPlacementTargetGetter, KeyboardAcceleratorPlacementTargetSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("keyboardAcceleratorPlacementMode").ToLocalChecked(), KeyboardAcceleratorPlacementModeGetter, KeyboardAcceleratorPlacementModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("keyTipTarget").ToLocalChecked(), KeyTipTargetGetter, KeyTipTargetSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("translationTransition").ToLocalChecked(), TranslationTransitionGetter, TranslationTransitionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("opacityTransition").ToLocalChecked(), OpacityTransitionGetter, OpacityTransitionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("transformMatrix").ToLocalChecked(), TransformMatrixGetter, TransformMatrixSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("scaleTransition").ToLocalChecked(), ScaleTransitionGetter, ScaleTransitionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("scale").ToLocalChecked(), ScaleGetter, ScaleSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("rotationTransition").ToLocalChecked(), RotationTransitionGetter, RotationTransitionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("rotationAxis").ToLocalChecked(), RotationAxisGetter, RotationAxisSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("rotation").ToLocalChecked(), RotationGetter, RotationSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("translation").ToLocalChecked(), TranslationGetter, TranslationSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("centerPoint").ToLocalChecked(), CenterPointGetter, CenterPointSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("canBeScrollAnchor").ToLocalChecked(), CanBeScrollAnchorGetter, CanBeScrollAnchorSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetMethod(constructor, "registerAsScrollPort", RegisterAsScrollPort);
        Nan::SetMethod(constructor, "tryStartDirectManipulation", TryStartDirectManipulation);
        Nan::SetAccessor(constructor, Nan::New<String>("holdingEvent").ToLocalChecked(), HoldingEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("isDoubleTapEnabledProperty").ToLocalChecked(), IsDoubleTapEnabledPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("isHitTestVisibleProperty").ToLocalChecked(), IsHitTestVisiblePropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("isHoldingEnabledProperty").ToLocalChecked(), IsHoldingEnabledPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("isRightTapEnabledProperty").ToLocalChecked(), IsRightTapEnabledPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("keyDownEvent").ToLocalChecked(), KeyDownEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("keyUpEvent").ToLocalChecked(), KeyUpEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("manipulationCompletedEvent").ToLocalChecked(), ManipulationCompletedEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("manipulationDeltaEvent").ToLocalChecked(), ManipulationDeltaEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("isTapEnabledProperty").ToLocalChecked(), IsTapEnabledPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("manipulationInertiaStartingEvent").ToLocalChecked(), ManipulationInertiaStartingEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("manipulationModeProperty").ToLocalChecked(), ManipulationModePropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("manipulationStartedEvent").ToLocalChecked(), ManipulationStartedEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("manipulationStartingEvent").ToLocalChecked(), ManipulationStartingEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("opacityProperty").ToLocalChecked(), OpacityPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("pointerCanceledEvent").ToLocalChecked(), PointerCanceledEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("pointerCaptureLostEvent").ToLocalChecked(), PointerCaptureLostEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("pointerCapturesProperty").ToLocalChecked(), PointerCapturesPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("pointerEnteredEvent").ToLocalChecked(), PointerEnteredEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("pointerExitedEvent").ToLocalChecked(), PointerExitedEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("pointerMovedEvent").ToLocalChecked(), PointerMovedEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("pointerPressedEvent").ToLocalChecked(), PointerPressedEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("pointerWheelChangedEvent").ToLocalChecked(), PointerWheelChangedEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("projectionProperty").ToLocalChecked(), ProjectionPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("renderTransformOriginProperty").ToLocalChecked(), RenderTransformOriginPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("renderTransformProperty").ToLocalChecked(), RenderTransformPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("rightTappedEvent").ToLocalChecked(), RightTappedEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("dragEnterEvent").ToLocalChecked(), DragEnterEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("tappedEvent").ToLocalChecked(), TappedEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("transitionsProperty").ToLocalChecked(), TransitionsPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("useLayoutRoundingProperty").ToLocalChecked(), UseLayoutRoundingPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("visibilityProperty").ToLocalChecked(), VisibilityPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("allowDropProperty").ToLocalChecked(), AllowDropPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("cacheModeProperty").ToLocalChecked(), CacheModePropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("clipProperty").ToLocalChecked(), ClipPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("doubleTappedEvent").ToLocalChecked(), DoubleTappedEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("pointerReleasedEvent").ToLocalChecked(), PointerReleasedEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("dragLeaveEvent").ToLocalChecked(), DragLeaveEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("dragOverEvent").ToLocalChecked(), DragOverEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("dropEvent").ToLocalChecked(), DropEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("shadowProperty").ToLocalChecked(), ShadowPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("compositeModeProperty").ToLocalChecked(), CompositeModePropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("canDragProperty").ToLocalChecked(), CanDragPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("transform3DProperty").ToLocalChecked(), Transform3DPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("accessKeyProperty").ToLocalChecked(), AccessKeyPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("accessKeyScopeOwnerProperty").ToLocalChecked(), AccessKeyScopeOwnerPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("contextFlyoutProperty").ToLocalChecked(), ContextFlyoutPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("isAccessKeyScopeProperty").ToLocalChecked(), IsAccessKeyScopePropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("exitDisplayModeOnAccessKeyInvokedProperty").ToLocalChecked(), ExitDisplayModeOnAccessKeyInvokedPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("highContrastAdjustmentProperty").ToLocalChecked(), HighContrastAdjustmentPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("keyTipHorizontalOffsetProperty").ToLocalChecked(), KeyTipHorizontalOffsetPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("keyTipPlacementModeProperty").ToLocalChecked(), KeyTipPlacementModePropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("keyTipVerticalOffsetProperty").ToLocalChecked(), KeyTipVerticalOffsetPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("lightsProperty").ToLocalChecked(), LightsPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("xYFocusDownNavigationStrategyProperty").ToLocalChecked(), XYFocusDownNavigationStrategyPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("xYFocusKeyboardNavigationProperty").ToLocalChecked(), XYFocusKeyboardNavigationPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("xYFocusLeftNavigationStrategyProperty").ToLocalChecked(), XYFocusLeftNavigationStrategyPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("xYFocusRightNavigationStrategyProperty").ToLocalChecked(), XYFocusRightNavigationStrategyPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("xYFocusUpNavigationStrategyProperty").ToLocalChecked(), XYFocusUpNavigationStrategyPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("tabFocusNavigationProperty").ToLocalChecked(), TabFocusNavigationPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("gettingFocusEvent").ToLocalChecked(), GettingFocusEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("losingFocusEvent").ToLocalChecked(), LosingFocusEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("noFocusCandidateFoundEvent").ToLocalChecked(), NoFocusCandidateFoundEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("characterReceivedEvent").ToLocalChecked(), CharacterReceivedEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("previewKeyDownEvent").ToLocalChecked(), PreviewKeyDownEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("previewKeyUpEvent").ToLocalChecked(), PreviewKeyUpEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("bringIntoViewRequestedEvent").ToLocalChecked(), BringIntoViewRequestedEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("contextRequestedEvent").ToLocalChecked(), ContextRequestedEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("keyTipTargetProperty").ToLocalChecked(), KeyTipTargetPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("keyboardAcceleratorPlacementModeProperty").ToLocalChecked(), KeyboardAcceleratorPlacementModePropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("keyboardAcceleratorPlacementTargetProperty").ToLocalChecked(), KeyboardAcceleratorPlacementTargetPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("canBeScrollAnchorProperty").ToLocalChecked(), CanBeScrollAnchorPropertyGetter);


        Nan::Set(exports, Nan::New<String>("UIElement").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      UIElement(::Windows::UI::Xaml::UIElement^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::UIElement^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::UIElement^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      UIElement *wrapperInstance = new UIElement(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::UIElement^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::UIElement^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapUIElement(winRtInstance));
    }

    static void StartDragAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      if (info.Length() == 0 || !info[info.Length() -1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: No callback was given")));
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::ApplicationModel::DataTransfer::DataPackageOperation>^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::PointerPoint^>(info[0]))
      {
        try
        {
          ::Windows::UI::Input::PointerPoint^ arg0 = dynamic_cast<::Windows::UI::Input::PointerPoint^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          op = wrapper->_instance->StartDragAsync(arg0);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

      auto opTask = create_task(op);
      uv_async_t* asyncToken = NodeUtils::Async::GetAsyncToken(info[info.Length() -1].As<Function>());

      opTask.then( [asyncToken] (task<::Windows::ApplicationModel::DataTransfer::DataPackageOperation> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = Nan::New<Integer>(static_cast<int>(result));
              if (tryCatch.HasCaught())
              {
                error = Nan::To<Object>(tryCatch.Exception()).ToLocalChecked();
              }
              else
              {
                error = Undefined();
              }
              if (arg1.IsEmpty()) arg1 = Undefined();
            }
            Local<Value> args[] = {error, arg1};


            invokeCallback(_countof(args), args);
          });
        } catch (Platform::Exception^ exception) {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {
            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

            Local<Value> args[] = {error};
            invokeCallback(_countof(args), args);
          });
        }
      });
    }

    static void OnCreateAutomationPeer(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::UI::Xaml::Automation::Peers::AutomationPeer^ result;
          result = wrapper->_instance->OnCreateAutomationPeer();
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Automation.Peers", "AutomationPeer", result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void OnDisconnectVisualChildren(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->OnDisconnectVisualChildren();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void FindSubElementsForTouchTargeting(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      if (info.Length() == 2
        && NodeRT::Utils::IsPoint(info[0])
        && NodeRT::Utils::IsRect(info[1]))
      {
        try
        {
          ::Windows::Foundation::Point arg0 = NodeRT::Utils::PointFromJs(info[0]);
          ::Windows::Foundation::Rect arg1 = NodeRT::Utils::RectFromJs(info[1]);
          
          ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Point>^>^ result;
          result = wrapper->_instance->FindSubElementsForTouchTargeting(arg0, arg1);
          info.GetReturnValue().Set(NodeRT::Collections::IterableWrapper<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Point>^>::CreateIterableWrapper(result, 
            [](::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Point>^ val) -> Local<Value> {
              return NodeRT::Collections::IterableWrapper<::Windows::Foundation::Point>::CreateIterableWrapper(val, 
            [](::Windows::Foundation::Point val) -> Local<Value> {
              return NodeRT::Utils::PointToJs(val);
            }
          );
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetChildrenInTabFocusOrder(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<::Windows::UI::Xaml::DependencyObject^>^ result;
          result = wrapper->_instance->GetChildrenInTabFocusOrder();
          info.GetReturnValue().Set(NodeRT::Collections::IterableWrapper<::Windows::UI::Xaml::DependencyObject^>::CreateIterableWrapper(result, 
            [](::Windows::UI::Xaml::DependencyObject^ val) -> Local<Value> {
              return WrapDependencyObject(val);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void OnProcessKeyboardAccelerators(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Input::ProcessKeyboardAcceleratorEventArgs^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::Input::ProcessKeyboardAcceleratorEventArgs^ arg0 = dynamic_cast<::Windows::UI::Xaml::Input::ProcessKeyboardAcceleratorEventArgs^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          wrapper->_instance->OnProcessKeyboardAccelerators(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void OnKeyboardAcceleratorInvoked(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Input::KeyboardAcceleratorInvokedEventArgs^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::Input::KeyboardAcceleratorInvokedEventArgs^ arg0 = dynamic_cast<::Windows::UI::Xaml::Input::KeyboardAcceleratorInvokedEventArgs^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          wrapper->_instance->OnKeyboardAcceleratorInvoked(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void OnBringIntoViewRequested(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^ arg0 = UnwrapBringIntoViewRequestedEventArgs(info[0]);
          
          wrapper->_instance->OnBringIntoViewRequested(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void PopulatePropertyInfoOverride(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      if (info.Length() == 2
        && info[0]->IsString()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::AnimationPropertyInfo^>(info[1]))
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::UI::Composition::AnimationPropertyInfo^ arg1 = dynamic_cast<::Windows::UI::Composition::AnimationPropertyInfo^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          wrapper->_instance->PopulatePropertyInfoOverride(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void PopulatePropertyInfo(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      if (info.Length() == 2
        && info[0]->IsString()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::AnimationPropertyInfo^>(info[1]))
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::UI::Composition::AnimationPropertyInfo^ arg1 = dynamic_cast<::Windows::UI::Composition::AnimationPropertyInfo^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          wrapper->_instance->PopulatePropertyInfo(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void StartBringIntoView(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->StartBringIntoView();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::BringIntoViewOptions^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::BringIntoViewOptions^ arg0 = UnwrapBringIntoViewOptions(info[0]);
          
          wrapper->_instance->StartBringIntoView(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void TryInvokeKeyboardAccelerator(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Input::ProcessKeyboardAcceleratorEventArgs^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::Input::ProcessKeyboardAcceleratorEventArgs^ arg0 = dynamic_cast<::Windows::UI::Xaml::Input::ProcessKeyboardAcceleratorEventArgs^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          wrapper->_instance->TryInvokeKeyboardAccelerator(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void StartAnimation(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::ICompositionAnimationBase^>(info[0]))
      {
        try
        {
          ::Windows::UI::Composition::ICompositionAnimationBase^ arg0 = dynamic_cast<::Windows::UI::Composition::ICompositionAnimationBase^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          wrapper->_instance->StartAnimation(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void StopAnimation(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::ICompositionAnimationBase^>(info[0]))
      {
        try
        {
          ::Windows::UI::Composition::ICompositionAnimationBase^ arg0 = dynamic_cast<::Windows::UI::Composition::ICompositionAnimationBase^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          wrapper->_instance->StopAnimation(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Measure(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsSize(info[0]))
      {
        try
        {
          ::Windows::Foundation::Size arg0 = NodeRT::Utils::SizeFromJs(info[0]);
          
          wrapper->_instance->Measure(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Arrange(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsRect(info[0]))
      {
        try
        {
          ::Windows::Foundation::Rect arg0 = NodeRT::Utils::RectFromJs(info[0]);
          
          wrapper->_instance->Arrange(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void CapturePointer(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Input::Pointer^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::Input::Pointer^ arg0 = dynamic_cast<::Windows::UI::Xaml::Input::Pointer^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          bool result;
          result = wrapper->_instance->CapturePointer(arg0);
          info.GetReturnValue().Set(Nan::New<Boolean>(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void ReleasePointerCapture(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Input::Pointer^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::Input::Pointer^ arg0 = dynamic_cast<::Windows::UI::Xaml::Input::Pointer^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          wrapper->_instance->ReleasePointerCapture(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void ReleasePointerCaptures(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->ReleasePointerCaptures();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void AddHandler(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::RoutedEvent^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[1])
        && info[2]->IsBoolean())
      {
        try
        {
          ::Windows::UI::Xaml::RoutedEvent^ arg0 = UnwrapRoutedEvent(info[0]);
          ::Platform::Object^ arg1 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[1]));
          bool arg2 = Nan::To<bool>(info[2]).FromMaybe(false);
          
          wrapper->_instance->AddHandler(arg0, arg1, arg2);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void RemoveHandler(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::RoutedEvent^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[1]))
      {
        try
        {
          ::Windows::UI::Xaml::RoutedEvent^ arg0 = UnwrapRoutedEvent(info[0]);
          ::Platform::Object^ arg1 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          wrapper->_instance->RemoveHandler(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void TransformToVisual(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::UIElement^ arg0 = UnwrapUIElement(info[0]);
          
          ::Windows::UI::Xaml::Media::GeneralTransform^ result;
          result = wrapper->_instance->TransformToVisual(arg0);
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Media", "GeneralTransform", result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void InvalidateMeasure(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->InvalidateMeasure();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void InvalidateArrange(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->InvalidateArrange();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void UpdateLayout(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->UpdateLayout();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void CancelDirectManipulations(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          bool result;
          result = wrapper->_instance->CancelDirectManipulations();
          info.GetReturnValue().Set(Nan::New<Boolean>(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    static void RegisterAsScrollPort(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::UIElement^ arg0 = UnwrapUIElement(info[0]);
          
          ::Windows::UI::Xaml::UIElement::RegisterAsScrollPort(arg0);
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void TryStartDirectManipulation(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Input::Pointer^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::Input::Pointer^ arg0 = dynamic_cast<::Windows::UI::Xaml::Input::Pointer^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          bool result;
          result = ::Windows::UI::Xaml::UIElement::TryStartDirectManipulation(arg0);
          info.GetReturnValue().Set(Nan::New<Boolean>(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void TransitionsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Media::Animation::TransitionCollection^ result = wrapper->_instance->Transitions;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Media.Animation", "TransitionCollection", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TransitionsSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Media::Animation::TransitionCollection^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Media::Animation::TransitionCollection^ winRtValue = dynamic_cast<::Windows::UI::Xaml::Media::Animation::TransitionCollection^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Transitions = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ProjectionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Media::Projection^ result = wrapper->_instance->Projection;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Media", "Projection", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ProjectionSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Media::Projection^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Media::Projection^ winRtValue = dynamic_cast<::Windows::UI::Xaml::Media::Projection^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Projection = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void RenderTransformOriginGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::Foundation::Point result = wrapper->_instance->RenderTransformOrigin;
        info.GetReturnValue().Set(NodeRT::Utils::PointToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RenderTransformOriginSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsPoint(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::Foundation::Point winRtValue = NodeRT::Utils::PointFromJs(value);

        wrapper->_instance->RenderTransformOrigin = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void OpacityGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        double result = wrapper->_instance->Opacity;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void OpacitySetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        double winRtValue = Nan::To<double>(value).FromMaybe(0.0);

        wrapper->_instance->Opacity = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ManipulationModeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Input::ManipulationModes result = wrapper->_instance->ManipulationMode;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ManipulationModeSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Input::ManipulationModes winRtValue = static_cast<::Windows::UI::Xaml::Input::ManipulationModes>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->ManipulationMode = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsTapEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        bool result = wrapper->_instance->IsTapEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsTapEnabledSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsTapEnabled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsRightTapEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        bool result = wrapper->_instance->IsRightTapEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsRightTapEnabledSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsRightTapEnabled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsHoldingEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        bool result = wrapper->_instance->IsHoldingEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsHoldingEnabledSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsHoldingEnabled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsHitTestVisibleGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        bool result = wrapper->_instance->IsHitTestVisible;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsHitTestVisibleSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsHitTestVisible = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsDoubleTapEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        bool result = wrapper->_instance->IsDoubleTapEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsDoubleTapEnabledSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsDoubleTapEnabled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void AllowDropGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        bool result = wrapper->_instance->AllowDrop;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AllowDropSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->AllowDrop = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ClipGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Media::RectangleGeometry^ result = wrapper->_instance->Clip;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Media", "RectangleGeometry", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ClipSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Media::RectangleGeometry^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Media::RectangleGeometry^ winRtValue = dynamic_cast<::Windows::UI::Xaml::Media::RectangleGeometry^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Clip = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void CacheModeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Media::CacheMode^ result = wrapper->_instance->CacheMode;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Media", "CacheMode", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CacheModeSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Media::CacheMode^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Media::CacheMode^ winRtValue = dynamic_cast<::Windows::UI::Xaml::Media::CacheMode^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->CacheMode = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void UseLayoutRoundingGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        bool result = wrapper->_instance->UseLayoutRounding;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void UseLayoutRoundingSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->UseLayoutRounding = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void RenderTransformGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Media::Transform^ result = wrapper->_instance->RenderTransform;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Media", "Transform", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RenderTransformSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Media::Transform^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Media::Transform^ winRtValue = dynamic_cast<::Windows::UI::Xaml::Media::Transform^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->RenderTransform = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void VisibilityGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Visibility result = wrapper->_instance->Visibility;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VisibilitySetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Visibility winRtValue = static_cast<::Windows::UI::Xaml::Visibility>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->Visibility = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void DesiredSizeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::Foundation::Size result = wrapper->_instance->DesiredSize;
        info.GetReturnValue().Set(NodeRT::Utils::SizeToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PointerCapturesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Xaml::Input::Pointer^>^ result = wrapper->_instance->PointerCaptures;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Xaml::Input::Pointer^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Xaml::Input::Pointer^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "Pointer", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Input::Pointer^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Xaml::Input::Pointer^ {
              return dynamic_cast<::Windows::UI::Xaml::Input::Pointer^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RenderSizeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::Foundation::Size result = wrapper->_instance->RenderSize;
        info.GetReturnValue().Set(NodeRT::Utils::SizeToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void XamlRootGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::XamlRoot^ result = wrapper->_instance->XamlRoot;
        info.GetReturnValue().Set(WrapXamlRoot(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void XamlRootSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::XamlRoot^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::XamlRoot^ winRtValue = dynamic_cast<::Windows::UI::Xaml::XamlRoot^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->XamlRoot = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ShadowGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Media::Shadow^ result = wrapper->_instance->Shadow;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Media", "Shadow", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ShadowSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Media::Shadow^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Media::Shadow^ winRtValue = dynamic_cast<::Windows::UI::Xaml::Media::Shadow^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Shadow = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ActualOffsetGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Platform::Numerics::Vector3 result = wrapper->_instance->ActualOffset;
        info.GetReturnValue().Set(Vector3ToJsObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ActualSizeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Platform::Numerics::Vector2 result = wrapper->_instance->ActualSize;
        info.GetReturnValue().Set(Vector2ToJsObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void UIContextGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::UIContext^ result = wrapper->_instance->UIContext;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI", "UIContext", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CompositeModeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Media::ElementCompositeMode result = wrapper->_instance->CompositeMode;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CompositeModeSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Media::ElementCompositeMode winRtValue = static_cast<::Windows::UI::Xaml::Media::ElementCompositeMode>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->CompositeMode = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void Transform3DGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Media::Media3D::Transform3D^ result = wrapper->_instance->Transform3D;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Media.Media3D", "Transform3D", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void Transform3DSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Media::Media3D::Transform3D^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Media::Media3D::Transform3D^ winRtValue = dynamic_cast<::Windows::UI::Xaml::Media::Media3D::Transform3D^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Transform3D = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void CanDragGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        bool result = wrapper->_instance->CanDrag;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CanDragSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->CanDrag = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsAccessKeyScopeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        bool result = wrapper->_instance->IsAccessKeyScope;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsAccessKeyScopeSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsAccessKeyScope = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ExitDisplayModeOnAccessKeyInvokedGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        bool result = wrapper->_instance->ExitDisplayModeOnAccessKeyInvoked;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ExitDisplayModeOnAccessKeyInvokedSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->ExitDisplayModeOnAccessKeyInvoked = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ContextFlyoutGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Controls::Primitives::FlyoutBase^ result = wrapper->_instance->ContextFlyout;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Controls.Primitives", "FlyoutBase", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ContextFlyoutSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Controls::Primitives::FlyoutBase^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Controls::Primitives::FlyoutBase^ winRtValue = dynamic_cast<::Windows::UI::Xaml::Controls::Primitives::FlyoutBase^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->ContextFlyout = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void AccessKeyScopeOwnerGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::DependencyObject^ result = wrapper->_instance->AccessKeyScopeOwner;
        info.GetReturnValue().Set(WrapDependencyObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AccessKeyScopeOwnerSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::DependencyObject^ winRtValue = dynamic_cast<::Windows::UI::Xaml::DependencyObject^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->AccessKeyScopeOwner = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void AccessKeyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->AccessKey;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AccessKeySetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsString()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->AccessKey = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void KeyTipHorizontalOffsetGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        double result = wrapper->_instance->KeyTipHorizontalOffset;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void KeyTipHorizontalOffsetSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        double winRtValue = Nan::To<double>(value).FromMaybe(0.0);

        wrapper->_instance->KeyTipHorizontalOffset = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void HighContrastAdjustmentGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::ElementHighContrastAdjustment result = wrapper->_instance->HighContrastAdjustment;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void HighContrastAdjustmentSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::ElementHighContrastAdjustment winRtValue = static_cast<::Windows::UI::Xaml::ElementHighContrastAdjustment>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->HighContrastAdjustment = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void XYFocusRightNavigationStrategyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Input::XYFocusNavigationStrategy result = wrapper->_instance->XYFocusRightNavigationStrategy;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void XYFocusRightNavigationStrategySetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Input::XYFocusNavigationStrategy winRtValue = static_cast<::Windows::UI::Xaml::Input::XYFocusNavigationStrategy>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->XYFocusRightNavigationStrategy = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void XYFocusKeyboardNavigationGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Input::XYFocusKeyboardNavigationMode result = wrapper->_instance->XYFocusKeyboardNavigation;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void XYFocusKeyboardNavigationSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Input::XYFocusKeyboardNavigationMode winRtValue = static_cast<::Windows::UI::Xaml::Input::XYFocusKeyboardNavigationMode>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->XYFocusKeyboardNavigation = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void XYFocusDownNavigationStrategyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Input::XYFocusNavigationStrategy result = wrapper->_instance->XYFocusDownNavigationStrategy;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void XYFocusDownNavigationStrategySetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Input::XYFocusNavigationStrategy winRtValue = static_cast<::Windows::UI::Xaml::Input::XYFocusNavigationStrategy>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->XYFocusDownNavigationStrategy = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void TabFocusNavigationGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Input::KeyboardNavigationMode result = wrapper->_instance->TabFocusNavigation;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TabFocusNavigationSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Input::KeyboardNavigationMode winRtValue = static_cast<::Windows::UI::Xaml::Input::KeyboardNavigationMode>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->TabFocusNavigation = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void KeyTipVerticalOffsetGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        double result = wrapper->_instance->KeyTipVerticalOffset;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void KeyTipVerticalOffsetSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        double winRtValue = Nan::To<double>(value).FromMaybe(0.0);

        wrapper->_instance->KeyTipVerticalOffset = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void XYFocusUpNavigationStrategyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Input::XYFocusNavigationStrategy result = wrapper->_instance->XYFocusUpNavigationStrategy;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void XYFocusUpNavigationStrategySetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Input::XYFocusNavigationStrategy winRtValue = static_cast<::Windows::UI::Xaml::Input::XYFocusNavigationStrategy>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->XYFocusUpNavigationStrategy = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void KeyTipPlacementModeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Input::KeyTipPlacementMode result = wrapper->_instance->KeyTipPlacementMode;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void KeyTipPlacementModeSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Input::KeyTipPlacementMode winRtValue = static_cast<::Windows::UI::Xaml::Input::KeyTipPlacementMode>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->KeyTipPlacementMode = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void XYFocusLeftNavigationStrategyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Input::XYFocusNavigationStrategy result = wrapper->_instance->XYFocusLeftNavigationStrategy;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void XYFocusLeftNavigationStrategySetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Input::XYFocusNavigationStrategy winRtValue = static_cast<::Windows::UI::Xaml::Input::XYFocusNavigationStrategy>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->XYFocusLeftNavigationStrategy = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void LightsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::UI::Xaml::Media::XamlLight^>^ result = wrapper->_instance->Lights;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::UI::Xaml::Media::XamlLight^>::CreateVectorWrapper(result, 
            [](::Windows::UI::Xaml::Media::XamlLight^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Media", "XamlLight", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Media::XamlLight^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Xaml::Media::XamlLight^ {
              return dynamic_cast<::Windows::UI::Xaml::Media::XamlLight^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void KeyboardAcceleratorsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::UI::Xaml::Input::KeyboardAccelerator^>^ result = wrapper->_instance->KeyboardAccelerators;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::UI::Xaml::Input::KeyboardAccelerator^>::CreateVectorWrapper(result, 
            [](::Windows::UI::Xaml::Input::KeyboardAccelerator^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "KeyboardAccelerator", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Input::KeyboardAccelerator^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Xaml::Input::KeyboardAccelerator^ {
              return dynamic_cast<::Windows::UI::Xaml::Input::KeyboardAccelerator^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void KeyboardAcceleratorPlacementTargetGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::DependencyObject^ result = wrapper->_instance->KeyboardAcceleratorPlacementTarget;
        info.GetReturnValue().Set(WrapDependencyObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void KeyboardAcceleratorPlacementTargetSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::DependencyObject^ winRtValue = dynamic_cast<::Windows::UI::Xaml::DependencyObject^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->KeyboardAcceleratorPlacementTarget = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void KeyboardAcceleratorPlacementModeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Input::KeyboardAcceleratorPlacementMode result = wrapper->_instance->KeyboardAcceleratorPlacementMode;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void KeyboardAcceleratorPlacementModeSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Input::KeyboardAcceleratorPlacementMode winRtValue = static_cast<::Windows::UI::Xaml::Input::KeyboardAcceleratorPlacementMode>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->KeyboardAcceleratorPlacementMode = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void KeyTipTargetGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::DependencyObject^ result = wrapper->_instance->KeyTipTarget;
        info.GetReturnValue().Set(WrapDependencyObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void KeyTipTargetSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::DependencyObject^ winRtValue = dynamic_cast<::Windows::UI::Xaml::DependencyObject^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->KeyTipTarget = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void TranslationTransitionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Vector3Transition^ result = wrapper->_instance->TranslationTransition;
        info.GetReturnValue().Set(WrapVector3Transition(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TranslationTransitionSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Vector3Transition^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Vector3Transition^ winRtValue = dynamic_cast<::Windows::UI::Xaml::Vector3Transition^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->TranslationTransition = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void OpacityTransitionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::ScalarTransition^ result = wrapper->_instance->OpacityTransition;
        info.GetReturnValue().Set(WrapScalarTransition(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void OpacityTransitionSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ScalarTransition^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::ScalarTransition^ winRtValue = dynamic_cast<::Windows::UI::Xaml::ScalarTransition^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->OpacityTransition = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void TransformMatrixGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Platform::Numerics::Matrix4x4 result = wrapper->_instance->TransformMatrix;
        info.GetReturnValue().Set(Matrix4x4ToJsObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TransformMatrixSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!IsMatrix4x4JsObject(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Platform::Numerics::Matrix4x4 winRtValue = Matrix4x4FromJsObject(value);

        wrapper->_instance->TransformMatrix = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ScaleTransitionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Vector3Transition^ result = wrapper->_instance->ScaleTransition;
        info.GetReturnValue().Set(WrapVector3Transition(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ScaleTransitionSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Vector3Transition^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Vector3Transition^ winRtValue = dynamic_cast<::Windows::UI::Xaml::Vector3Transition^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->ScaleTransition = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ScaleGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Platform::Numerics::Vector3 result = wrapper->_instance->Scale;
        info.GetReturnValue().Set(Vector3ToJsObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ScaleSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!IsVector3JsObject(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Platform::Numerics::Vector3 winRtValue = Vector3FromJsObject(value);

        wrapper->_instance->Scale = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void RotationTransitionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::ScalarTransition^ result = wrapper->_instance->RotationTransition;
        info.GetReturnValue().Set(WrapScalarTransition(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RotationTransitionSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ScalarTransition^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::ScalarTransition^ winRtValue = dynamic_cast<::Windows::UI::Xaml::ScalarTransition^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->RotationTransition = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void RotationAxisGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Platform::Numerics::Vector3 result = wrapper->_instance->RotationAxis;
        info.GetReturnValue().Set(Vector3ToJsObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RotationAxisSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!IsVector3JsObject(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Platform::Numerics::Vector3 winRtValue = Vector3FromJsObject(value);

        wrapper->_instance->RotationAxis = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void RotationGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        float result = wrapper->_instance->Rotation;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RotationSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        float winRtValue = static_cast<float>(Nan::To<double>(value).FromMaybe(0.0));

        wrapper->_instance->Rotation = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void TranslationGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Platform::Numerics::Vector3 result = wrapper->_instance->Translation;
        info.GetReturnValue().Set(Vector3ToJsObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TranslationSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!IsVector3JsObject(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Platform::Numerics::Vector3 winRtValue = Vector3FromJsObject(value);

        wrapper->_instance->Translation = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void CenterPointGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Platform::Numerics::Vector3 result = wrapper->_instance->CenterPoint;
        info.GetReturnValue().Set(Vector3ToJsObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CenterPointSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!IsVector3JsObject(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Platform::Numerics::Vector3 winRtValue = Vector3FromJsObject(value);

        wrapper->_instance->CenterPoint = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void CanBeScrollAnchorGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        bool result = wrapper->_instance->CanBeScrollAnchor;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CanBeScrollAnchorSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->CanBeScrollAnchor = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void DispatcherGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      try  {
        ::Windows::UI::Core::CoreDispatcher^ result = wrapper->_instance->Dispatcher;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "CoreDispatcher", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    static void HoldingEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::HoldingEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void IsDoubleTapEnabledPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::IsDoubleTapEnabledProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void IsHitTestVisiblePropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::IsHitTestVisibleProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void IsHoldingEnabledPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::IsHoldingEnabledProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void IsRightTapEnabledPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::IsRightTapEnabledProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void KeyDownEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::KeyDownEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void KeyUpEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::KeyUpEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void ManipulationCompletedEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::ManipulationCompletedEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void ManipulationDeltaEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::ManipulationDeltaEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void IsTapEnabledPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::IsTapEnabledProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void ManipulationInertiaStartingEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::ManipulationInertiaStartingEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void ManipulationModePropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::ManipulationModeProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void ManipulationStartedEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::ManipulationStartedEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void ManipulationStartingEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::ManipulationStartingEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void OpacityPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::OpacityProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void PointerCanceledEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::PointerCanceledEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void PointerCaptureLostEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::PointerCaptureLostEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void PointerCapturesPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::PointerCapturesProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void PointerEnteredEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::PointerEnteredEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void PointerExitedEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::PointerExitedEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void PointerMovedEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::PointerMovedEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void PointerPressedEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::PointerPressedEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void PointerWheelChangedEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::PointerWheelChangedEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void ProjectionPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::ProjectionProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void RenderTransformOriginPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::RenderTransformOriginProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void RenderTransformPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::RenderTransformProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void RightTappedEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::RightTappedEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void DragEnterEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::DragEnterEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void TappedEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::TappedEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void TransitionsPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::TransitionsProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void UseLayoutRoundingPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::UseLayoutRoundingProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void VisibilityPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::VisibilityProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void AllowDropPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::AllowDropProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void CacheModePropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::CacheModeProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void ClipPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::ClipProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void DoubleTappedEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::DoubleTappedEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void PointerReleasedEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::PointerReleasedEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void DragLeaveEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::DragLeaveEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void DragOverEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::DragOverEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void DropEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::DropEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void ShadowPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::ShadowProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void CompositeModePropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::CompositeModeProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void CanDragPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::CanDragProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void Transform3DPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::Transform3DProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void AccessKeyPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::AccessKeyProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void AccessKeyScopeOwnerPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::AccessKeyScopeOwnerProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void ContextFlyoutPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::ContextFlyoutProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void IsAccessKeyScopePropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::IsAccessKeyScopeProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void ExitDisplayModeOnAccessKeyInvokedPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::ExitDisplayModeOnAccessKeyInvokedProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void HighContrastAdjustmentPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::HighContrastAdjustmentProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void KeyTipHorizontalOffsetPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::KeyTipHorizontalOffsetProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void KeyTipPlacementModePropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::KeyTipPlacementModeProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void KeyTipVerticalOffsetPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::KeyTipVerticalOffsetProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void LightsPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::LightsProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void XYFocusDownNavigationStrategyPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::XYFocusDownNavigationStrategyProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void XYFocusKeyboardNavigationPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::XYFocusKeyboardNavigationProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void XYFocusLeftNavigationStrategyPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::XYFocusLeftNavigationStrategyProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void XYFocusRightNavigationStrategyPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::XYFocusRightNavigationStrategyProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void XYFocusUpNavigationStrategyPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::XYFocusUpNavigationStrategyProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void TabFocusNavigationPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::TabFocusNavigationProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void GettingFocusEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::GettingFocusEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void LosingFocusEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::LosingFocusEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void NoFocusCandidateFoundEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::NoFocusCandidateFoundEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void CharacterReceivedEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::CharacterReceivedEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void PreviewKeyDownEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::PreviewKeyDownEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void PreviewKeyUpEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::PreviewKeyUpEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void BringIntoViewRequestedEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::BringIntoViewRequestedEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void ContextRequestedEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::ContextRequestedEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void KeyTipTargetPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::KeyTipTargetProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void KeyboardAcceleratorPlacementModePropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::KeyboardAcceleratorPlacementModeProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void KeyboardAcceleratorPlacementTargetPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::KeyboardAcceleratorPlacementTargetProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void CanBeScrollAnchorPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::CanBeScrollAnchorProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void AddListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"doubleTapped", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->DoubleTapped::add(
            ref new ::Windows::UI::Xaml::Input::DoubleTappedEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::DoubleTappedRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "DoubleTappedRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"dragEnter", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->DragEnter::add(
            ref new ::Windows::UI::Xaml::DragEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::DragEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = WrapDragEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"dragLeave", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->DragLeave::add(
            ref new ::Windows::UI::Xaml::DragEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::DragEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = WrapDragEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"dragOver", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->DragOver::add(
            ref new ::Windows::UI::Xaml::DragEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::DragEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = WrapDragEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"drop", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->Drop::add(
            ref new ::Windows::UI::Xaml::DragEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::DragEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = WrapDragEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"gotFocus", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->GotFocus::add(
            ref new ::Windows::UI::Xaml::RoutedEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::RoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = WrapRoutedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"holding", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->Holding::add(
            ref new ::Windows::UI::Xaml::Input::HoldingEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::HoldingRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "HoldingRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"keyDown", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->KeyDown::add(
            ref new ::Windows::UI::Xaml::Input::KeyEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::KeyRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "KeyRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"keyUp", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->KeyUp::add(
            ref new ::Windows::UI::Xaml::Input::KeyEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::KeyRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "KeyRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"lostFocus", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->LostFocus::add(
            ref new ::Windows::UI::Xaml::RoutedEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::RoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = WrapRoutedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"manipulationCompleted", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->ManipulationCompleted::add(
            ref new ::Windows::UI::Xaml::Input::ManipulationCompletedEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::ManipulationCompletedRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "ManipulationCompletedRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"manipulationDelta", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->ManipulationDelta::add(
            ref new ::Windows::UI::Xaml::Input::ManipulationDeltaEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::ManipulationDeltaRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "ManipulationDeltaRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"manipulationInertiaStarting", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->ManipulationInertiaStarting::add(
            ref new ::Windows::UI::Xaml::Input::ManipulationInertiaStartingEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::ManipulationInertiaStartingRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "ManipulationInertiaStartingRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"manipulationStarted", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->ManipulationStarted::add(
            ref new ::Windows::UI::Xaml::Input::ManipulationStartedEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::ManipulationStartedRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "ManipulationStartedRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"manipulationStarting", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->ManipulationStarting::add(
            ref new ::Windows::UI::Xaml::Input::ManipulationStartingEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::ManipulationStartingRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "ManipulationStartingRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerCanceled", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PointerCanceled::add(
            ref new ::Windows::UI::Xaml::Input::PointerEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::PointerRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "PointerRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerCaptureLost", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PointerCaptureLost::add(
            ref new ::Windows::UI::Xaml::Input::PointerEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::PointerRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "PointerRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerEntered", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PointerEntered::add(
            ref new ::Windows::UI::Xaml::Input::PointerEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::PointerRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "PointerRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerExited", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PointerExited::add(
            ref new ::Windows::UI::Xaml::Input::PointerEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::PointerRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "PointerRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerMoved", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PointerMoved::add(
            ref new ::Windows::UI::Xaml::Input::PointerEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::PointerRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "PointerRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerPressed", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PointerPressed::add(
            ref new ::Windows::UI::Xaml::Input::PointerEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::PointerRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "PointerRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerReleased", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PointerReleased::add(
            ref new ::Windows::UI::Xaml::Input::PointerEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::PointerRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "PointerRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerWheelChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PointerWheelChanged::add(
            ref new ::Windows::UI::Xaml::Input::PointerEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::PointerRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "PointerRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"rightTapped", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->RightTapped::add(
            ref new ::Windows::UI::Xaml::Input::RightTappedEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::RightTappedRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "RightTappedRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"tapped", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->Tapped::add(
            ref new ::Windows::UI::Xaml::Input::TappedEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::TappedRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "TappedRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"dragStarting", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->DragStarting::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::UIElement^, ::Windows::UI::Xaml::DragStartingEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::UIElement^ arg0, ::Windows::UI::Xaml::DragStartingEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUIElement(arg0);
                  wrappedArg1 = WrapDragStartingEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"dropCompleted", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->DropCompleted::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::UIElement^, ::Windows::UI::Xaml::DropCompletedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::UIElement^ arg0, ::Windows::UI::Xaml::DropCompletedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUIElement(arg0);
                  wrappedArg1 = WrapDropCompletedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"accessKeyDisplayDismissed", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->AccessKeyDisplayDismissed::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::UIElement^, ::Windows::UI::Xaml::Input::AccessKeyDisplayDismissedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::UIElement^ arg0, ::Windows::UI::Xaml::Input::AccessKeyDisplayDismissedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUIElement(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "AccessKeyDisplayDismissedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"accessKeyDisplayRequested", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->AccessKeyDisplayRequested::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::UIElement^, ::Windows::UI::Xaml::Input::AccessKeyDisplayRequestedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::UIElement^ arg0, ::Windows::UI::Xaml::Input::AccessKeyDisplayRequestedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUIElement(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "AccessKeyDisplayRequestedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"accessKeyInvoked", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->AccessKeyInvoked::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::UIElement^, ::Windows::UI::Xaml::Input::AccessKeyInvokedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::UIElement^ arg0, ::Windows::UI::Xaml::Input::AccessKeyInvokedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUIElement(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "AccessKeyInvokedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"contextCanceled", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->ContextCanceled::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::UIElement^, ::Windows::UI::Xaml::RoutedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::UIElement^ arg0, ::Windows::UI::Xaml::RoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUIElement(arg0);
                  wrappedArg1 = WrapRoutedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"contextRequested", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->ContextRequested::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::UIElement^, ::Windows::UI::Xaml::Input::ContextRequestedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::UIElement^ arg0, ::Windows::UI::Xaml::Input::ContextRequestedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUIElement(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "ContextRequestedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"gettingFocus", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->GettingFocus::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::UIElement^, ::Windows::UI::Xaml::Input::GettingFocusEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::UIElement^ arg0, ::Windows::UI::Xaml::Input::GettingFocusEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUIElement(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "GettingFocusEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"losingFocus", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->LosingFocus::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::UIElement^, ::Windows::UI::Xaml::Input::LosingFocusEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::UIElement^ arg0, ::Windows::UI::Xaml::Input::LosingFocusEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUIElement(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "LosingFocusEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"noFocusCandidateFound", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->NoFocusCandidateFound::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::UIElement^, ::Windows::UI::Xaml::Input::NoFocusCandidateFoundEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::UIElement^ arg0, ::Windows::UI::Xaml::Input::NoFocusCandidateFoundEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUIElement(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "NoFocusCandidateFoundEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"characterReceived", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->CharacterReceived::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::UIElement^, ::Windows::UI::Xaml::Input::CharacterReceivedRoutedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::UIElement^ arg0, ::Windows::UI::Xaml::Input::CharacterReceivedRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUIElement(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "CharacterReceivedRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"previewKeyDown", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PreviewKeyDown::add(
            ref new ::Windows::UI::Xaml::Input::KeyEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::KeyRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "KeyRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"previewKeyUp", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PreviewKeyUp::add(
            ref new ::Windows::UI::Xaml::Input::KeyEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::KeyRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "KeyRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"processKeyboardAccelerators", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->ProcessKeyboardAccelerators::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::UIElement^, ::Windows::UI::Xaml::Input::ProcessKeyboardAcceleratorEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::UIElement^ arg0, ::Windows::UI::Xaml::Input::ProcessKeyboardAcceleratorEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUIElement(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "ProcessKeyboardAcceleratorEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"bringIntoViewRequested", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->BringIntoViewRequested::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::UIElement^, ::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::UIElement^ arg0, ::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUIElement(arg0);
                  wrappedArg1 = WrapBringIntoViewRequestedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
 else  {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Value> tokenMapVal = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());
      Local<Object> tokenMap;

      if (tokenMapVal.IsEmpty() || Nan::Equals(tokenMapVal, Undefined()).FromMaybe(false)) {
        tokenMap = Nan::New<Object>();
        NodeRT::Utils::SetHiddenValueWithObject(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked(), tokenMap);
      } else {
        tokenMap = Nan::To<Object>(tokenMapVal).ToLocalChecked();
      }

      Nan::Set(tokenMap, info[0], CreateOpaqueWrapper(::Windows::Foundation::PropertyValue::CreateInt64(registrationToken.Value)));
    }

    static void RemoveListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected a string and a callback")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      if ((!NodeRT::Utils::CaseInsenstiveEquals(L"doubleTapped", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"dragEnter", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"dragLeave", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"dragOver", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"drop", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"gotFocus", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"holding", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"keyDown", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"keyUp", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"lostFocus", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"manipulationCompleted", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"manipulationDelta", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"manipulationInertiaStarting", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"manipulationStarted", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"manipulationStarting", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"pointerCanceled", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"pointerCaptureLost", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"pointerEntered", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"pointerExited", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"pointerMoved", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"pointerPressed", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"pointerReleased", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"pointerWheelChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"rightTapped", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"tapped", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"dragStarting", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"dropCompleted", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"accessKeyDisplayDismissed", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"accessKeyDisplayRequested", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"accessKeyInvoked", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"contextCanceled", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"contextRequested", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"gettingFocus", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"losingFocus", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"noFocusCandidateFound", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"characterReceived", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"previewKeyDown", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"previewKeyUp", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"processKeyboardAccelerators", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"bringIntoViewRequested", str))) {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Function> callback = info[1].As<Function>();
      Local<Value> tokenMap = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());

      if (tokenMap.IsEmpty() || Nan::Equals(tokenMap, Undefined()).FromMaybe(false)) {
        return;
      }

      Local<Value> opaqueWrapperObj =  Nan::Get(Nan::To<Object>(tokenMap).ToLocalChecked(), info[0]).ToLocalChecked();

      if (opaqueWrapperObj.IsEmpty() || Nan::Equals(opaqueWrapperObj,Undefined()).FromMaybe(false)) {
        return;
      }

      OpaqueWrapper *opaqueWrapper = OpaqueWrapper::Unwrap<OpaqueWrapper>(opaqueWrapperObj.As<Object>());

      long long tokenValue = (long long) opaqueWrapper->GetObjectInstance();
      ::Windows::Foundation::EventRegistrationToken registrationToken;
      registrationToken.Value = tokenValue;

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"doubleTapped", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->DoubleTapped::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"dragEnter", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->DragEnter::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"dragLeave", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->DragLeave::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"dragOver", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->DragOver::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"drop", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->Drop::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"gotFocus", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->GotFocus::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"holding", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->Holding::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"keyDown", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->KeyDown::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"keyUp", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->KeyUp::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"lostFocus", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->LostFocus::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"manipulationCompleted", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->ManipulationCompleted::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"manipulationDelta", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->ManipulationDelta::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"manipulationInertiaStarting", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->ManipulationInertiaStarting::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"manipulationStarted", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->ManipulationStarted::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"manipulationStarting", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->ManipulationStarting::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerCanceled", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->PointerCanceled::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerCaptureLost", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->PointerCaptureLost::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerEntered", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->PointerEntered::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerExited", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->PointerExited::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerMoved", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->PointerMoved::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerPressed", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->PointerPressed::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerReleased", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->PointerReleased::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerWheelChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->PointerWheelChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"rightTapped", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->RightTapped::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"tapped", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->Tapped::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"dragStarting", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->DragStarting::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"dropCompleted", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->DropCompleted::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"accessKeyDisplayDismissed", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->AccessKeyDisplayDismissed::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"accessKeyDisplayRequested", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->AccessKeyDisplayRequested::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"accessKeyInvoked", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->AccessKeyInvoked::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"contextCanceled", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->ContextCanceled::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"contextRequested", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->ContextRequested::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"gettingFocus", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->GettingFocus::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"losingFocus", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->LosingFocus::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"noFocusCandidateFound", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->NoFocusCandidateFound::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"characterReceived", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->CharacterReceived::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"previewKeyDown", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->PreviewKeyDown::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"previewKeyUp", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->PreviewKeyUp::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"processKeyboardAccelerators", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->ProcessKeyboardAccelerators::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"bringIntoViewRequested", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());
          wrapper->_instance->BringIntoViewRequested::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

      Nan::Delete(Nan::To<Object>(tokenMap).ToLocalChecked(), Nan::To<String>(info[0]).ToLocalChecked());
    }
    private:
      ::Windows::UI::Xaml::UIElement^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapUIElement(::Windows::UI::Xaml::UIElement^ wintRtInstance);
      friend ::Windows::UI::Xaml::UIElement^ UnwrapUIElement(Local<Value> value);
  };

  Persistent<FunctionTemplate> UIElement::s_constructorTemplate;

  v8::Local<v8::Value> WrapUIElement(::Windows::UI::Xaml::UIElement^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(UIElement::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::UIElement^ UnwrapUIElement(Local<Value> value) {
     return UIElement::Unwrap<UIElement>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitUIElement(Local<Object> exports) {
    UIElement::Init(exports);
  }

  class FrameworkElement : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("FrameworkElement").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "getBindingExpression", GetBindingExpression);
            Nan::SetPrototypeMethod(localRef, "invalidateViewport", InvalidateViewport);
            Nan::SetPrototypeMethod(localRef, "measureOverride", MeasureOverride);
            Nan::SetPrototypeMethod(localRef, "arrangeOverride", ArrangeOverride);
            Nan::SetPrototypeMethod(localRef, "onApplyTemplate", OnApplyTemplate);
            Nan::SetPrototypeMethod(localRef, "goToElementStateCore", GoToElementStateCore);
            Nan::SetPrototypeMethod(localRef, "findName", FindName);
            Nan::SetPrototypeMethod(localRef, "setBinding", SetBinding);
          


          
          Nan::SetPrototypeMethod(localRef,"addListener", AddListener);
          Nan::SetPrototypeMethod(localRef,"on", AddListener);
          Nan::SetPrototypeMethod(localRef,"removeListener", RemoveListener);
          Nan::SetPrototypeMethod(localRef, "off", RemoveListener);

          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("width").ToLocalChecked(), WidthGetter, WidthSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("verticalAlignment").ToLocalChecked(), VerticalAlignmentGetter, VerticalAlignmentSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("tag").ToLocalChecked(), TagGetter, TagSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("style").ToLocalChecked(), StyleGetter, StyleSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("resources").ToLocalChecked(), ResourcesGetter, ResourcesSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("name").ToLocalChecked(), NameGetter, NameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("minWidth").ToLocalChecked(), MinWidthGetter, MinWidthSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("minHeight").ToLocalChecked(), MinHeightGetter, MinHeightSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxWidth").ToLocalChecked(), MaxWidthGetter, MaxWidthSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxHeight").ToLocalChecked(), MaxHeightGetter, MaxHeightSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("margin").ToLocalChecked(), MarginGetter, MarginSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("language").ToLocalChecked(), LanguageGetter, LanguageSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("horizontalAlignment").ToLocalChecked(), HorizontalAlignmentGetter, HorizontalAlignmentSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("height").ToLocalChecked(), HeightGetter, HeightSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("flowDirection").ToLocalChecked(), FlowDirectionGetter, FlowDirectionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dataContext").ToLocalChecked(), DataContextGetter, DataContextSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("actualHeight").ToLocalChecked(), ActualHeightGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("actualWidth").ToLocalChecked(), ActualWidthGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("baseUri").ToLocalChecked(), BaseUriGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("parent").ToLocalChecked(), ParentGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("triggers").ToLocalChecked(), TriggersGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("requestedTheme").ToLocalChecked(), RequestedThemeGetter, RequestedThemeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("focusVisualSecondaryThickness").ToLocalChecked(), FocusVisualSecondaryThicknessGetter, FocusVisualSecondaryThicknessSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("focusVisualSecondaryBrush").ToLocalChecked(), FocusVisualSecondaryBrushGetter, FocusVisualSecondaryBrushSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("focusVisualPrimaryThickness").ToLocalChecked(), FocusVisualPrimaryThicknessGetter, FocusVisualPrimaryThicknessSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("focusVisualPrimaryBrush").ToLocalChecked(), FocusVisualPrimaryBrushGetter, FocusVisualPrimaryBrushSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("focusVisualMargin").ToLocalChecked(), FocusVisualMarginGetter, FocusVisualMarginSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("allowFocusWhenDisabled").ToLocalChecked(), AllowFocusWhenDisabledGetter, AllowFocusWhenDisabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("allowFocusOnInteraction").ToLocalChecked(), AllowFocusOnInteractionGetter, AllowFocusOnInteractionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("actualTheme").ToLocalChecked(), ActualThemeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isLoaded").ToLocalChecked(), IsLoadedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("transitions").ToLocalChecked(), TransitionsGetter, TransitionsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("projection").ToLocalChecked(), ProjectionGetter, ProjectionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("renderTransformOrigin").ToLocalChecked(), RenderTransformOriginGetter, RenderTransformOriginSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("opacity").ToLocalChecked(), OpacityGetter, OpacitySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("manipulationMode").ToLocalChecked(), ManipulationModeGetter, ManipulationModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isTapEnabled").ToLocalChecked(), IsTapEnabledGetter, IsTapEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isRightTapEnabled").ToLocalChecked(), IsRightTapEnabledGetter, IsRightTapEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isHoldingEnabled").ToLocalChecked(), IsHoldingEnabledGetter, IsHoldingEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isHitTestVisible").ToLocalChecked(), IsHitTestVisibleGetter, IsHitTestVisibleSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isDoubleTapEnabled").ToLocalChecked(), IsDoubleTapEnabledGetter, IsDoubleTapEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("allowDrop").ToLocalChecked(), AllowDropGetter, AllowDropSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("clip").ToLocalChecked(), ClipGetter, ClipSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("cacheMode").ToLocalChecked(), CacheModeGetter, CacheModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("useLayoutRounding").ToLocalChecked(), UseLayoutRoundingGetter, UseLayoutRoundingSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("renderTransform").ToLocalChecked(), RenderTransformGetter, RenderTransformSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("visibility").ToLocalChecked(), VisibilityGetter, VisibilitySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("desiredSize").ToLocalChecked(), DesiredSizeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pointerCaptures").ToLocalChecked(), PointerCapturesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("renderSize").ToLocalChecked(), RenderSizeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("xamlRoot").ToLocalChecked(), XamlRootGetter, XamlRootSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("shadow").ToLocalChecked(), ShadowGetter, ShadowSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("actualOffset").ToLocalChecked(), ActualOffsetGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("actualSize").ToLocalChecked(), ActualSizeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("uIContext").ToLocalChecked(), UIContextGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("compositeMode").ToLocalChecked(), CompositeModeGetter, CompositeModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("transform3D").ToLocalChecked(), Transform3DGetter, Transform3DSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("canDrag").ToLocalChecked(), CanDragGetter, CanDragSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isAccessKeyScope").ToLocalChecked(), IsAccessKeyScopeGetter, IsAccessKeyScopeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("exitDisplayModeOnAccessKeyInvoked").ToLocalChecked(), ExitDisplayModeOnAccessKeyInvokedGetter, ExitDisplayModeOnAccessKeyInvokedSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("contextFlyout").ToLocalChecked(), ContextFlyoutGetter, ContextFlyoutSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("accessKeyScopeOwner").ToLocalChecked(), AccessKeyScopeOwnerGetter, AccessKeyScopeOwnerSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("accessKey").ToLocalChecked(), AccessKeyGetter, AccessKeySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("keyTipHorizontalOffset").ToLocalChecked(), KeyTipHorizontalOffsetGetter, KeyTipHorizontalOffsetSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("highContrastAdjustment").ToLocalChecked(), HighContrastAdjustmentGetter, HighContrastAdjustmentSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("xYFocusRightNavigationStrategy").ToLocalChecked(), XYFocusRightNavigationStrategyGetter, XYFocusRightNavigationStrategySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("xYFocusKeyboardNavigation").ToLocalChecked(), XYFocusKeyboardNavigationGetter, XYFocusKeyboardNavigationSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("xYFocusDownNavigationStrategy").ToLocalChecked(), XYFocusDownNavigationStrategyGetter, XYFocusDownNavigationStrategySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("tabFocusNavigation").ToLocalChecked(), TabFocusNavigationGetter, TabFocusNavigationSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("keyTipVerticalOffset").ToLocalChecked(), KeyTipVerticalOffsetGetter, KeyTipVerticalOffsetSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("xYFocusUpNavigationStrategy").ToLocalChecked(), XYFocusUpNavigationStrategyGetter, XYFocusUpNavigationStrategySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("keyTipPlacementMode").ToLocalChecked(), KeyTipPlacementModeGetter, KeyTipPlacementModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("xYFocusLeftNavigationStrategy").ToLocalChecked(), XYFocusLeftNavigationStrategyGetter, XYFocusLeftNavigationStrategySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("lights").ToLocalChecked(), LightsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("keyboardAccelerators").ToLocalChecked(), KeyboardAcceleratorsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("keyboardAcceleratorPlacementTarget").ToLocalChecked(), KeyboardAcceleratorPlacementTargetGetter, KeyboardAcceleratorPlacementTargetSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("keyboardAcceleratorPlacementMode").ToLocalChecked(), KeyboardAcceleratorPlacementModeGetter, KeyboardAcceleratorPlacementModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("keyTipTarget").ToLocalChecked(), KeyTipTargetGetter, KeyTipTargetSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("translationTransition").ToLocalChecked(), TranslationTransitionGetter, TranslationTransitionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("opacityTransition").ToLocalChecked(), OpacityTransitionGetter, OpacityTransitionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("transformMatrix").ToLocalChecked(), TransformMatrixGetter, TransformMatrixSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("scaleTransition").ToLocalChecked(), ScaleTransitionGetter, ScaleTransitionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("scale").ToLocalChecked(), ScaleGetter, ScaleSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("rotationTransition").ToLocalChecked(), RotationTransitionGetter, RotationTransitionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("rotationAxis").ToLocalChecked(), RotationAxisGetter, RotationAxisSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("rotation").ToLocalChecked(), RotationGetter, RotationSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("translation").ToLocalChecked(), TranslationGetter, TranslationSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("centerPoint").ToLocalChecked(), CenterPointGetter, CenterPointSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("canBeScrollAnchor").ToLocalChecked(), CanBeScrollAnchorGetter, CanBeScrollAnchorSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetMethod(constructor, "deferTree", DeferTree);
        Nan::SetAccessor(constructor, Nan::New<String>("actualHeightProperty").ToLocalChecked(), ActualHeightPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("actualWidthProperty").ToLocalChecked(), ActualWidthPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("dataContextProperty").ToLocalChecked(), DataContextPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("flowDirectionProperty").ToLocalChecked(), FlowDirectionPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("heightProperty").ToLocalChecked(), HeightPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("horizontalAlignmentProperty").ToLocalChecked(), HorizontalAlignmentPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("languageProperty").ToLocalChecked(), LanguagePropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("marginProperty").ToLocalChecked(), MarginPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("maxHeightProperty").ToLocalChecked(), MaxHeightPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("maxWidthProperty").ToLocalChecked(), MaxWidthPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("minHeightProperty").ToLocalChecked(), MinHeightPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("minWidthProperty").ToLocalChecked(), MinWidthPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("nameProperty").ToLocalChecked(), NamePropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("styleProperty").ToLocalChecked(), StylePropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("tagProperty").ToLocalChecked(), TagPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("verticalAlignmentProperty").ToLocalChecked(), VerticalAlignmentPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("widthProperty").ToLocalChecked(), WidthPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("requestedThemeProperty").ToLocalChecked(), RequestedThemePropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("allowFocusOnInteractionProperty").ToLocalChecked(), AllowFocusOnInteractionPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("allowFocusWhenDisabledProperty").ToLocalChecked(), AllowFocusWhenDisabledPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("focusVisualMarginProperty").ToLocalChecked(), FocusVisualMarginPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("focusVisualPrimaryBrushProperty").ToLocalChecked(), FocusVisualPrimaryBrushPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("focusVisualPrimaryThicknessProperty").ToLocalChecked(), FocusVisualPrimaryThicknessPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("focusVisualSecondaryBrushProperty").ToLocalChecked(), FocusVisualSecondaryBrushPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("focusVisualSecondaryThicknessProperty").ToLocalChecked(), FocusVisualSecondaryThicknessPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("actualThemeProperty").ToLocalChecked(), ActualThemePropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("holdingEvent").ToLocalChecked(), HoldingEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("isDoubleTapEnabledProperty").ToLocalChecked(), IsDoubleTapEnabledPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("isHitTestVisibleProperty").ToLocalChecked(), IsHitTestVisiblePropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("isHoldingEnabledProperty").ToLocalChecked(), IsHoldingEnabledPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("isRightTapEnabledProperty").ToLocalChecked(), IsRightTapEnabledPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("keyDownEvent").ToLocalChecked(), KeyDownEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("keyUpEvent").ToLocalChecked(), KeyUpEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("manipulationCompletedEvent").ToLocalChecked(), ManipulationCompletedEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("manipulationDeltaEvent").ToLocalChecked(), ManipulationDeltaEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("isTapEnabledProperty").ToLocalChecked(), IsTapEnabledPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("manipulationInertiaStartingEvent").ToLocalChecked(), ManipulationInertiaStartingEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("manipulationModeProperty").ToLocalChecked(), ManipulationModePropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("manipulationStartedEvent").ToLocalChecked(), ManipulationStartedEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("manipulationStartingEvent").ToLocalChecked(), ManipulationStartingEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("opacityProperty").ToLocalChecked(), OpacityPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("pointerCanceledEvent").ToLocalChecked(), PointerCanceledEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("pointerCaptureLostEvent").ToLocalChecked(), PointerCaptureLostEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("pointerCapturesProperty").ToLocalChecked(), PointerCapturesPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("pointerEnteredEvent").ToLocalChecked(), PointerEnteredEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("pointerExitedEvent").ToLocalChecked(), PointerExitedEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("pointerMovedEvent").ToLocalChecked(), PointerMovedEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("pointerPressedEvent").ToLocalChecked(), PointerPressedEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("pointerWheelChangedEvent").ToLocalChecked(), PointerWheelChangedEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("projectionProperty").ToLocalChecked(), ProjectionPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("renderTransformOriginProperty").ToLocalChecked(), RenderTransformOriginPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("renderTransformProperty").ToLocalChecked(), RenderTransformPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("rightTappedEvent").ToLocalChecked(), RightTappedEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("dragEnterEvent").ToLocalChecked(), DragEnterEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("tappedEvent").ToLocalChecked(), TappedEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("transitionsProperty").ToLocalChecked(), TransitionsPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("useLayoutRoundingProperty").ToLocalChecked(), UseLayoutRoundingPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("visibilityProperty").ToLocalChecked(), VisibilityPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("allowDropProperty").ToLocalChecked(), AllowDropPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("cacheModeProperty").ToLocalChecked(), CacheModePropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("clipProperty").ToLocalChecked(), ClipPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("doubleTappedEvent").ToLocalChecked(), DoubleTappedEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("pointerReleasedEvent").ToLocalChecked(), PointerReleasedEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("dragLeaveEvent").ToLocalChecked(), DragLeaveEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("dragOverEvent").ToLocalChecked(), DragOverEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("dropEvent").ToLocalChecked(), DropEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("shadowProperty").ToLocalChecked(), ShadowPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("compositeModeProperty").ToLocalChecked(), CompositeModePropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("canDragProperty").ToLocalChecked(), CanDragPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("transform3DProperty").ToLocalChecked(), Transform3DPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("accessKeyProperty").ToLocalChecked(), AccessKeyPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("accessKeyScopeOwnerProperty").ToLocalChecked(), AccessKeyScopeOwnerPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("contextFlyoutProperty").ToLocalChecked(), ContextFlyoutPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("isAccessKeyScopeProperty").ToLocalChecked(), IsAccessKeyScopePropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("exitDisplayModeOnAccessKeyInvokedProperty").ToLocalChecked(), ExitDisplayModeOnAccessKeyInvokedPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("highContrastAdjustmentProperty").ToLocalChecked(), HighContrastAdjustmentPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("keyTipHorizontalOffsetProperty").ToLocalChecked(), KeyTipHorizontalOffsetPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("keyTipPlacementModeProperty").ToLocalChecked(), KeyTipPlacementModePropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("keyTipVerticalOffsetProperty").ToLocalChecked(), KeyTipVerticalOffsetPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("lightsProperty").ToLocalChecked(), LightsPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("xYFocusDownNavigationStrategyProperty").ToLocalChecked(), XYFocusDownNavigationStrategyPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("xYFocusKeyboardNavigationProperty").ToLocalChecked(), XYFocusKeyboardNavigationPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("xYFocusLeftNavigationStrategyProperty").ToLocalChecked(), XYFocusLeftNavigationStrategyPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("xYFocusRightNavigationStrategyProperty").ToLocalChecked(), XYFocusRightNavigationStrategyPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("xYFocusUpNavigationStrategyProperty").ToLocalChecked(), XYFocusUpNavigationStrategyPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("tabFocusNavigationProperty").ToLocalChecked(), TabFocusNavigationPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("gettingFocusEvent").ToLocalChecked(), GettingFocusEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("losingFocusEvent").ToLocalChecked(), LosingFocusEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("noFocusCandidateFoundEvent").ToLocalChecked(), NoFocusCandidateFoundEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("characterReceivedEvent").ToLocalChecked(), CharacterReceivedEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("previewKeyDownEvent").ToLocalChecked(), PreviewKeyDownEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("previewKeyUpEvent").ToLocalChecked(), PreviewKeyUpEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("bringIntoViewRequestedEvent").ToLocalChecked(), BringIntoViewRequestedEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("contextRequestedEvent").ToLocalChecked(), ContextRequestedEventGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("keyTipTargetProperty").ToLocalChecked(), KeyTipTargetPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("keyboardAcceleratorPlacementModeProperty").ToLocalChecked(), KeyboardAcceleratorPlacementModePropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("keyboardAcceleratorPlacementTargetProperty").ToLocalChecked(), KeyboardAcceleratorPlacementTargetPropertyGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("canBeScrollAnchorProperty").ToLocalChecked(), CanBeScrollAnchorPropertyGetter);


        Nan::Set(exports, Nan::New<String>("FrameworkElement").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      FrameworkElement(::Windows::UI::Xaml::FrameworkElement^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::FrameworkElement^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::FrameworkElement^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      FrameworkElement *wrapperInstance = new FrameworkElement(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::FrameworkElement^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::FrameworkElement^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapFrameworkElement(winRtInstance));
    }


    static void GetBindingExpression(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyProperty^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::DependencyProperty^ arg0 = UnwrapDependencyProperty(info[0]);
          
          ::Windows::UI::Xaml::Data::BindingExpression^ result;
          result = wrapper->_instance->GetBindingExpression(arg0);
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Data", "BindingExpression", result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void InvalidateViewport(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->InvalidateViewport();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void MeasureOverride(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsSize(info[0]))
      {
        try
        {
          ::Windows::Foundation::Size arg0 = NodeRT::Utils::SizeFromJs(info[0]);
          
          ::Windows::Foundation::Size result;
          result = wrapper->_instance->MeasureOverride(arg0);
          info.GetReturnValue().Set(NodeRT::Utils::SizeToJs(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void ArrangeOverride(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsSize(info[0]))
      {
        try
        {
          ::Windows::Foundation::Size arg0 = NodeRT::Utils::SizeFromJs(info[0]);
          
          ::Windows::Foundation::Size result;
          result = wrapper->_instance->ArrangeOverride(arg0);
          info.GetReturnValue().Set(NodeRT::Utils::SizeToJs(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void OnApplyTemplate(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->OnApplyTemplate();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GoToElementStateCore(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      if (info.Length() == 2
        && info[0]->IsString()
        && info[1]->IsBoolean())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          bool arg1 = Nan::To<bool>(info[1]).FromMaybe(false);
          
          bool result;
          result = wrapper->_instance->GoToElementStateCore(arg0, arg1);
          info.GetReturnValue().Set(Nan::New<Boolean>(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void FindName(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          ::Platform::Object^ result;
          result = wrapper->_instance->FindName(arg0);
          info.GetReturnValue().Set(CreateOpaqueWrapper(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void SetBinding(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyProperty^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Data::BindingBase^>(info[1]))
      {
        try
        {
          ::Windows::UI::Xaml::DependencyProperty^ arg0 = UnwrapDependencyProperty(info[0]);
          ::Windows::UI::Xaml::Data::BindingBase^ arg1 = dynamic_cast<::Windows::UI::Xaml::Data::BindingBase^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          wrapper->_instance->SetBinding(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    static void DeferTree(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::DependencyObject^ arg0 = UnwrapDependencyObject(info[0]);
          
          ::Windows::UI::Xaml::FrameworkElement::DeferTree(arg0);
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void WidthGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        double result = wrapper->_instance->Width;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void WidthSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try {

        double winRtValue = Nan::To<double>(value).FromMaybe(0.0);

        wrapper->_instance->Width = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void VerticalAlignmentGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        ::Windows::UI::Xaml::VerticalAlignment result = wrapper->_instance->VerticalAlignment;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VerticalAlignmentSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try {

        ::Windows::UI::Xaml::VerticalAlignment winRtValue = static_cast<::Windows::UI::Xaml::VerticalAlignment>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->VerticalAlignment = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void TagGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        ::Platform::Object^ result = wrapper->_instance->Tag;
        info.GetReturnValue().Set(CreateOpaqueWrapper(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TagSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try {

        ::Platform::Object^ winRtValue = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Tag = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void StyleGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Style^ result = wrapper->_instance->Style;
        info.GetReturnValue().Set(WrapStyle(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void StyleSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Style^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try {

        ::Windows::UI::Xaml::Style^ winRtValue = dynamic_cast<::Windows::UI::Xaml::Style^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Style = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ResourcesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        ::Windows::UI::Xaml::ResourceDictionary^ result = wrapper->_instance->Resources;
        info.GetReturnValue().Set(WrapResourceDictionary(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ResourcesSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ResourceDictionary^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try {

        ::Windows::UI::Xaml::ResourceDictionary^ winRtValue = dynamic_cast<::Windows::UI::Xaml::ResourceDictionary^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Resources = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void NameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Name;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void NameSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsString()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->Name = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void MinWidthGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        double result = wrapper->_instance->MinWidth;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MinWidthSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try {

        double winRtValue = Nan::To<double>(value).FromMaybe(0.0);

        wrapper->_instance->MinWidth = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void MinHeightGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        double result = wrapper->_instance->MinHeight;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MinHeightSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try {

        double winRtValue = Nan::To<double>(value).FromMaybe(0.0);

        wrapper->_instance->MinHeight = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void MaxWidthGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        double result = wrapper->_instance->MaxWidth;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MaxWidthSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try {

        double winRtValue = Nan::To<double>(value).FromMaybe(0.0);

        wrapper->_instance->MaxWidth = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void MaxHeightGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        double result = wrapper->_instance->MaxHeight;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MaxHeightSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try {

        double winRtValue = Nan::To<double>(value).FromMaybe(0.0);

        wrapper->_instance->MaxHeight = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void MarginGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Thickness result = wrapper->_instance->Margin;
        info.GetReturnValue().Set(ThicknessToJsObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MarginSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!IsThicknessJsObject(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try {

        ::Windows::UI::Xaml::Thickness winRtValue = ThicknessFromJsObject(value);

        wrapper->_instance->Margin = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void LanguageGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Language;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void LanguageSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsString()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->Language = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void HorizontalAlignmentGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        ::Windows::UI::Xaml::HorizontalAlignment result = wrapper->_instance->HorizontalAlignment;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void HorizontalAlignmentSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try {

        ::Windows::UI::Xaml::HorizontalAlignment winRtValue = static_cast<::Windows::UI::Xaml::HorizontalAlignment>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->HorizontalAlignment = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void HeightGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        double result = wrapper->_instance->Height;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void HeightSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try {

        double winRtValue = Nan::To<double>(value).FromMaybe(0.0);

        wrapper->_instance->Height = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void FlowDirectionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        ::Windows::UI::Xaml::FlowDirection result = wrapper->_instance->FlowDirection;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void FlowDirectionSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try {

        ::Windows::UI::Xaml::FlowDirection winRtValue = static_cast<::Windows::UI::Xaml::FlowDirection>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->FlowDirection = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void DataContextGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        ::Platform::Object^ result = wrapper->_instance->DataContext;
        info.GetReturnValue().Set(CreateOpaqueWrapper(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DataContextSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try {

        ::Platform::Object^ winRtValue = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->DataContext = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ActualHeightGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        double result = wrapper->_instance->ActualHeight;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ActualWidthGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        double result = wrapper->_instance->ActualWidth;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BaseUriGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        ::Windows::Foundation::Uri^ result = wrapper->_instance->BaseUri;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "Uri", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ParentGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        ::Windows::UI::Xaml::DependencyObject^ result = wrapper->_instance->Parent;
        info.GetReturnValue().Set(WrapDependencyObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TriggersGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        ::Windows::UI::Xaml::TriggerCollection^ result = wrapper->_instance->Triggers;
        info.GetReturnValue().Set(WrapTriggerCollection(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RequestedThemeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        ::Windows::UI::Xaml::ElementTheme result = wrapper->_instance->RequestedTheme;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RequestedThemeSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try {

        ::Windows::UI::Xaml::ElementTheme winRtValue = static_cast<::Windows::UI::Xaml::ElementTheme>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->RequestedTheme = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void FocusVisualSecondaryThicknessGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Thickness result = wrapper->_instance->FocusVisualSecondaryThickness;
        info.GetReturnValue().Set(ThicknessToJsObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void FocusVisualSecondaryThicknessSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!IsThicknessJsObject(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try {

        ::Windows::UI::Xaml::Thickness winRtValue = ThicknessFromJsObject(value);

        wrapper->_instance->FocusVisualSecondaryThickness = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void FocusVisualSecondaryBrushGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Media::Brush^ result = wrapper->_instance->FocusVisualSecondaryBrush;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Media", "Brush", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void FocusVisualSecondaryBrushSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Media::Brush^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try {

        ::Windows::UI::Xaml::Media::Brush^ winRtValue = dynamic_cast<::Windows::UI::Xaml::Media::Brush^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->FocusVisualSecondaryBrush = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void FocusVisualPrimaryThicknessGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Thickness result = wrapper->_instance->FocusVisualPrimaryThickness;
        info.GetReturnValue().Set(ThicknessToJsObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void FocusVisualPrimaryThicknessSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!IsThicknessJsObject(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try {

        ::Windows::UI::Xaml::Thickness winRtValue = ThicknessFromJsObject(value);

        wrapper->_instance->FocusVisualPrimaryThickness = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void FocusVisualPrimaryBrushGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Media::Brush^ result = wrapper->_instance->FocusVisualPrimaryBrush;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Media", "Brush", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void FocusVisualPrimaryBrushSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Media::Brush^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try {

        ::Windows::UI::Xaml::Media::Brush^ winRtValue = dynamic_cast<::Windows::UI::Xaml::Media::Brush^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->FocusVisualPrimaryBrush = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void FocusVisualMarginGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Thickness result = wrapper->_instance->FocusVisualMargin;
        info.GetReturnValue().Set(ThicknessToJsObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void FocusVisualMarginSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!IsThicknessJsObject(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try {

        ::Windows::UI::Xaml::Thickness winRtValue = ThicknessFromJsObject(value);

        wrapper->_instance->FocusVisualMargin = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void AllowFocusWhenDisabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        bool result = wrapper->_instance->AllowFocusWhenDisabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AllowFocusWhenDisabledSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->AllowFocusWhenDisabled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void AllowFocusOnInteractionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        bool result = wrapper->_instance->AllowFocusOnInteraction;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AllowFocusOnInteractionSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->AllowFocusOnInteraction = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ActualThemeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        ::Windows::UI::Xaml::ElementTheme result = wrapper->_instance->ActualTheme;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsLoadedGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This())) {
        return;
      }

      FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());

      try  {
        bool result = wrapper->_instance->IsLoaded;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TransitionsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Media::Animation::TransitionCollection^ result = wrapper->_instance->Transitions;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Media.Animation", "TransitionCollection", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TransitionsSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Media::Animation::TransitionCollection^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Media::Animation::TransitionCollection^ winRtValue = dynamic_cast<::Windows::UI::Xaml::Media::Animation::TransitionCollection^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Transitions = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ProjectionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Media::Projection^ result = wrapper->_instance->Projection;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Media", "Projection", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ProjectionSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Media::Projection^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Media::Projection^ winRtValue = dynamic_cast<::Windows::UI::Xaml::Media::Projection^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Projection = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void RenderTransformOriginGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::Foundation::Point result = wrapper->_instance->RenderTransformOrigin;
        info.GetReturnValue().Set(NodeRT::Utils::PointToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RenderTransformOriginSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsPoint(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::Foundation::Point winRtValue = NodeRT::Utils::PointFromJs(value);

        wrapper->_instance->RenderTransformOrigin = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void OpacityGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        double result = wrapper->_instance->Opacity;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void OpacitySetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        double winRtValue = Nan::To<double>(value).FromMaybe(0.0);

        wrapper->_instance->Opacity = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ManipulationModeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Input::ManipulationModes result = wrapper->_instance->ManipulationMode;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ManipulationModeSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Input::ManipulationModes winRtValue = static_cast<::Windows::UI::Xaml::Input::ManipulationModes>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->ManipulationMode = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsTapEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        bool result = wrapper->_instance->IsTapEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsTapEnabledSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsTapEnabled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsRightTapEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        bool result = wrapper->_instance->IsRightTapEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsRightTapEnabledSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsRightTapEnabled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsHoldingEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        bool result = wrapper->_instance->IsHoldingEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsHoldingEnabledSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsHoldingEnabled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsHitTestVisibleGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        bool result = wrapper->_instance->IsHitTestVisible;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsHitTestVisibleSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsHitTestVisible = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsDoubleTapEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        bool result = wrapper->_instance->IsDoubleTapEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsDoubleTapEnabledSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsDoubleTapEnabled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void AllowDropGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        bool result = wrapper->_instance->AllowDrop;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AllowDropSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->AllowDrop = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ClipGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Media::RectangleGeometry^ result = wrapper->_instance->Clip;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Media", "RectangleGeometry", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ClipSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Media::RectangleGeometry^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Media::RectangleGeometry^ winRtValue = dynamic_cast<::Windows::UI::Xaml::Media::RectangleGeometry^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Clip = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void CacheModeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Media::CacheMode^ result = wrapper->_instance->CacheMode;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Media", "CacheMode", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CacheModeSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Media::CacheMode^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Media::CacheMode^ winRtValue = dynamic_cast<::Windows::UI::Xaml::Media::CacheMode^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->CacheMode = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void UseLayoutRoundingGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        bool result = wrapper->_instance->UseLayoutRounding;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void UseLayoutRoundingSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->UseLayoutRounding = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void RenderTransformGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Media::Transform^ result = wrapper->_instance->RenderTransform;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Media", "Transform", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RenderTransformSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Media::Transform^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Media::Transform^ winRtValue = dynamic_cast<::Windows::UI::Xaml::Media::Transform^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->RenderTransform = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void VisibilityGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Visibility result = wrapper->_instance->Visibility;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VisibilitySetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Visibility winRtValue = static_cast<::Windows::UI::Xaml::Visibility>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->Visibility = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void DesiredSizeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::Foundation::Size result = wrapper->_instance->DesiredSize;
        info.GetReturnValue().Set(NodeRT::Utils::SizeToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PointerCapturesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Xaml::Input::Pointer^>^ result = wrapper->_instance->PointerCaptures;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Xaml::Input::Pointer^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Xaml::Input::Pointer^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "Pointer", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Input::Pointer^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Xaml::Input::Pointer^ {
              return dynamic_cast<::Windows::UI::Xaml::Input::Pointer^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RenderSizeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::Foundation::Size result = wrapper->_instance->RenderSize;
        info.GetReturnValue().Set(NodeRT::Utils::SizeToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void XamlRootGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::XamlRoot^ result = wrapper->_instance->XamlRoot;
        info.GetReturnValue().Set(WrapXamlRoot(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void XamlRootSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::XamlRoot^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::XamlRoot^ winRtValue = dynamic_cast<::Windows::UI::Xaml::XamlRoot^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->XamlRoot = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ShadowGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Media::Shadow^ result = wrapper->_instance->Shadow;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Media", "Shadow", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ShadowSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Media::Shadow^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Media::Shadow^ winRtValue = dynamic_cast<::Windows::UI::Xaml::Media::Shadow^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Shadow = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ActualOffsetGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Platform::Numerics::Vector3 result = wrapper->_instance->ActualOffset;
        info.GetReturnValue().Set(Vector3ToJsObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ActualSizeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Platform::Numerics::Vector2 result = wrapper->_instance->ActualSize;
        info.GetReturnValue().Set(Vector2ToJsObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void UIContextGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::UIContext^ result = wrapper->_instance->UIContext;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI", "UIContext", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CompositeModeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Media::ElementCompositeMode result = wrapper->_instance->CompositeMode;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CompositeModeSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Media::ElementCompositeMode winRtValue = static_cast<::Windows::UI::Xaml::Media::ElementCompositeMode>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->CompositeMode = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void Transform3DGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Media::Media3D::Transform3D^ result = wrapper->_instance->Transform3D;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Media.Media3D", "Transform3D", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void Transform3DSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Media::Media3D::Transform3D^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Media::Media3D::Transform3D^ winRtValue = dynamic_cast<::Windows::UI::Xaml::Media::Media3D::Transform3D^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Transform3D = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void CanDragGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        bool result = wrapper->_instance->CanDrag;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CanDragSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->CanDrag = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsAccessKeyScopeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        bool result = wrapper->_instance->IsAccessKeyScope;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsAccessKeyScopeSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsAccessKeyScope = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ExitDisplayModeOnAccessKeyInvokedGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        bool result = wrapper->_instance->ExitDisplayModeOnAccessKeyInvoked;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ExitDisplayModeOnAccessKeyInvokedSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->ExitDisplayModeOnAccessKeyInvoked = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ContextFlyoutGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Controls::Primitives::FlyoutBase^ result = wrapper->_instance->ContextFlyout;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Controls.Primitives", "FlyoutBase", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ContextFlyoutSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Controls::Primitives::FlyoutBase^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Controls::Primitives::FlyoutBase^ winRtValue = dynamic_cast<::Windows::UI::Xaml::Controls::Primitives::FlyoutBase^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->ContextFlyout = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void AccessKeyScopeOwnerGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::DependencyObject^ result = wrapper->_instance->AccessKeyScopeOwner;
        info.GetReturnValue().Set(WrapDependencyObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AccessKeyScopeOwnerSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::DependencyObject^ winRtValue = dynamic_cast<::Windows::UI::Xaml::DependencyObject^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->AccessKeyScopeOwner = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void AccessKeyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->AccessKey;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AccessKeySetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsString()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->AccessKey = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void KeyTipHorizontalOffsetGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        double result = wrapper->_instance->KeyTipHorizontalOffset;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void KeyTipHorizontalOffsetSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        double winRtValue = Nan::To<double>(value).FromMaybe(0.0);

        wrapper->_instance->KeyTipHorizontalOffset = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void HighContrastAdjustmentGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::ElementHighContrastAdjustment result = wrapper->_instance->HighContrastAdjustment;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void HighContrastAdjustmentSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::ElementHighContrastAdjustment winRtValue = static_cast<::Windows::UI::Xaml::ElementHighContrastAdjustment>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->HighContrastAdjustment = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void XYFocusRightNavigationStrategyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Input::XYFocusNavigationStrategy result = wrapper->_instance->XYFocusRightNavigationStrategy;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void XYFocusRightNavigationStrategySetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Input::XYFocusNavigationStrategy winRtValue = static_cast<::Windows::UI::Xaml::Input::XYFocusNavigationStrategy>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->XYFocusRightNavigationStrategy = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void XYFocusKeyboardNavigationGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Input::XYFocusKeyboardNavigationMode result = wrapper->_instance->XYFocusKeyboardNavigation;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void XYFocusKeyboardNavigationSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Input::XYFocusKeyboardNavigationMode winRtValue = static_cast<::Windows::UI::Xaml::Input::XYFocusKeyboardNavigationMode>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->XYFocusKeyboardNavigation = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void XYFocusDownNavigationStrategyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Input::XYFocusNavigationStrategy result = wrapper->_instance->XYFocusDownNavigationStrategy;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void XYFocusDownNavigationStrategySetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Input::XYFocusNavigationStrategy winRtValue = static_cast<::Windows::UI::Xaml::Input::XYFocusNavigationStrategy>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->XYFocusDownNavigationStrategy = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void TabFocusNavigationGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Input::KeyboardNavigationMode result = wrapper->_instance->TabFocusNavigation;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TabFocusNavigationSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Input::KeyboardNavigationMode winRtValue = static_cast<::Windows::UI::Xaml::Input::KeyboardNavigationMode>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->TabFocusNavigation = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void KeyTipVerticalOffsetGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        double result = wrapper->_instance->KeyTipVerticalOffset;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void KeyTipVerticalOffsetSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        double winRtValue = Nan::To<double>(value).FromMaybe(0.0);

        wrapper->_instance->KeyTipVerticalOffset = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void XYFocusUpNavigationStrategyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Input::XYFocusNavigationStrategy result = wrapper->_instance->XYFocusUpNavigationStrategy;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void XYFocusUpNavigationStrategySetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Input::XYFocusNavigationStrategy winRtValue = static_cast<::Windows::UI::Xaml::Input::XYFocusNavigationStrategy>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->XYFocusUpNavigationStrategy = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void KeyTipPlacementModeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Input::KeyTipPlacementMode result = wrapper->_instance->KeyTipPlacementMode;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void KeyTipPlacementModeSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Input::KeyTipPlacementMode winRtValue = static_cast<::Windows::UI::Xaml::Input::KeyTipPlacementMode>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->KeyTipPlacementMode = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void XYFocusLeftNavigationStrategyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Input::XYFocusNavigationStrategy result = wrapper->_instance->XYFocusLeftNavigationStrategy;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void XYFocusLeftNavigationStrategySetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Input::XYFocusNavigationStrategy winRtValue = static_cast<::Windows::UI::Xaml::Input::XYFocusNavigationStrategy>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->XYFocusLeftNavigationStrategy = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void LightsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::UI::Xaml::Media::XamlLight^>^ result = wrapper->_instance->Lights;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::UI::Xaml::Media::XamlLight^>::CreateVectorWrapper(result, 
            [](::Windows::UI::Xaml::Media::XamlLight^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Media", "XamlLight", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Media::XamlLight^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Xaml::Media::XamlLight^ {
              return dynamic_cast<::Windows::UI::Xaml::Media::XamlLight^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void KeyboardAcceleratorsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::UI::Xaml::Input::KeyboardAccelerator^>^ result = wrapper->_instance->KeyboardAccelerators;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::UI::Xaml::Input::KeyboardAccelerator^>::CreateVectorWrapper(result, 
            [](::Windows::UI::Xaml::Input::KeyboardAccelerator^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "KeyboardAccelerator", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Input::KeyboardAccelerator^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Xaml::Input::KeyboardAccelerator^ {
              return dynamic_cast<::Windows::UI::Xaml::Input::KeyboardAccelerator^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void KeyboardAcceleratorPlacementTargetGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::DependencyObject^ result = wrapper->_instance->KeyboardAcceleratorPlacementTarget;
        info.GetReturnValue().Set(WrapDependencyObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void KeyboardAcceleratorPlacementTargetSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::DependencyObject^ winRtValue = dynamic_cast<::Windows::UI::Xaml::DependencyObject^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->KeyboardAcceleratorPlacementTarget = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void KeyboardAcceleratorPlacementModeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Input::KeyboardAcceleratorPlacementMode result = wrapper->_instance->KeyboardAcceleratorPlacementMode;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void KeyboardAcceleratorPlacementModeSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Input::KeyboardAcceleratorPlacementMode winRtValue = static_cast<::Windows::UI::Xaml::Input::KeyboardAcceleratorPlacementMode>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->KeyboardAcceleratorPlacementMode = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void KeyTipTargetGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::DependencyObject^ result = wrapper->_instance->KeyTipTarget;
        info.GetReturnValue().Set(WrapDependencyObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void KeyTipTargetSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::DependencyObject^ winRtValue = dynamic_cast<::Windows::UI::Xaml::DependencyObject^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->KeyTipTarget = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void TranslationTransitionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Vector3Transition^ result = wrapper->_instance->TranslationTransition;
        info.GetReturnValue().Set(WrapVector3Transition(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TranslationTransitionSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Vector3Transition^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Vector3Transition^ winRtValue = dynamic_cast<::Windows::UI::Xaml::Vector3Transition^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->TranslationTransition = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void OpacityTransitionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::ScalarTransition^ result = wrapper->_instance->OpacityTransition;
        info.GetReturnValue().Set(WrapScalarTransition(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void OpacityTransitionSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ScalarTransition^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::ScalarTransition^ winRtValue = dynamic_cast<::Windows::UI::Xaml::ScalarTransition^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->OpacityTransition = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void TransformMatrixGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Platform::Numerics::Matrix4x4 result = wrapper->_instance->TransformMatrix;
        info.GetReturnValue().Set(Matrix4x4ToJsObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TransformMatrixSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!IsMatrix4x4JsObject(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Platform::Numerics::Matrix4x4 winRtValue = Matrix4x4FromJsObject(value);

        wrapper->_instance->TransformMatrix = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ScaleTransitionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::Vector3Transition^ result = wrapper->_instance->ScaleTransition;
        info.GetReturnValue().Set(WrapVector3Transition(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ScaleTransitionSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Vector3Transition^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::Vector3Transition^ winRtValue = dynamic_cast<::Windows::UI::Xaml::Vector3Transition^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->ScaleTransition = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ScaleGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Platform::Numerics::Vector3 result = wrapper->_instance->Scale;
        info.GetReturnValue().Set(Vector3ToJsObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ScaleSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!IsVector3JsObject(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Platform::Numerics::Vector3 winRtValue = Vector3FromJsObject(value);

        wrapper->_instance->Scale = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void RotationTransitionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Windows::UI::Xaml::ScalarTransition^ result = wrapper->_instance->RotationTransition;
        info.GetReturnValue().Set(WrapScalarTransition(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RotationTransitionSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ScalarTransition^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Windows::UI::Xaml::ScalarTransition^ winRtValue = dynamic_cast<::Windows::UI::Xaml::ScalarTransition^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->RotationTransition = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void RotationAxisGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Platform::Numerics::Vector3 result = wrapper->_instance->RotationAxis;
        info.GetReturnValue().Set(Vector3ToJsObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RotationAxisSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!IsVector3JsObject(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Platform::Numerics::Vector3 winRtValue = Vector3FromJsObject(value);

        wrapper->_instance->RotationAxis = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void RotationGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        float result = wrapper->_instance->Rotation;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RotationSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        float winRtValue = static_cast<float>(Nan::To<double>(value).FromMaybe(0.0));

        wrapper->_instance->Rotation = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void TranslationGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Platform::Numerics::Vector3 result = wrapper->_instance->Translation;
        info.GetReturnValue().Set(Vector3ToJsObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TranslationSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!IsVector3JsObject(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Platform::Numerics::Vector3 winRtValue = Vector3FromJsObject(value);

        wrapper->_instance->Translation = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void CenterPointGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        ::Platform::Numerics::Vector3 result = wrapper->_instance->CenterPoint;
        info.GetReturnValue().Set(Vector3ToJsObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CenterPointSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!IsVector3JsObject(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        ::Platform::Numerics::Vector3 winRtValue = Vector3FromJsObject(value);

        wrapper->_instance->CenterPoint = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void CanBeScrollAnchorGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try  {
        bool result = wrapper->_instance->CanBeScrollAnchor;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CanBeScrollAnchorSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info.This())) {
        return;
      }

      UIElement *wrapper = UIElement::Unwrap<UIElement>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->CanBeScrollAnchor = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void DispatcherGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      try  {
        ::Windows::UI::Core::CoreDispatcher^ result = wrapper->_instance->Dispatcher;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "CoreDispatcher", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    static void ActualHeightPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::FrameworkElement::ActualHeightProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void ActualWidthPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::FrameworkElement::ActualWidthProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void DataContextPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::FrameworkElement::DataContextProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void FlowDirectionPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::FrameworkElement::FlowDirectionProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void HeightPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::FrameworkElement::HeightProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void HorizontalAlignmentPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::FrameworkElement::HorizontalAlignmentProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void LanguagePropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::FrameworkElement::LanguageProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void MarginPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::FrameworkElement::MarginProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void MaxHeightPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::FrameworkElement::MaxHeightProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void MaxWidthPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::FrameworkElement::MaxWidthProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void MinHeightPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::FrameworkElement::MinHeightProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void MinWidthPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::FrameworkElement::MinWidthProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void NamePropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::FrameworkElement::NameProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void StylePropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::FrameworkElement::StyleProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void TagPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::FrameworkElement::TagProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void VerticalAlignmentPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::FrameworkElement::VerticalAlignmentProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void WidthPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::FrameworkElement::WidthProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void RequestedThemePropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::FrameworkElement::RequestedThemeProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void AllowFocusOnInteractionPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::FrameworkElement::AllowFocusOnInteractionProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void AllowFocusWhenDisabledPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::FrameworkElement::AllowFocusWhenDisabledProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void FocusVisualMarginPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::FrameworkElement::FocusVisualMarginProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void FocusVisualPrimaryBrushPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::FrameworkElement::FocusVisualPrimaryBrushProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void FocusVisualPrimaryThicknessPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::FrameworkElement::FocusVisualPrimaryThicknessProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void FocusVisualSecondaryBrushPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::FrameworkElement::FocusVisualSecondaryBrushProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void FocusVisualSecondaryThicknessPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::FrameworkElement::FocusVisualSecondaryThicknessProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void ActualThemePropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::FrameworkElement::ActualThemeProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void HoldingEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::HoldingEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void IsDoubleTapEnabledPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::IsDoubleTapEnabledProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void IsHitTestVisiblePropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::IsHitTestVisibleProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void IsHoldingEnabledPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::IsHoldingEnabledProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void IsRightTapEnabledPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::IsRightTapEnabledProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void KeyDownEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::KeyDownEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void KeyUpEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::KeyUpEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void ManipulationCompletedEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::ManipulationCompletedEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void ManipulationDeltaEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::ManipulationDeltaEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void IsTapEnabledPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::IsTapEnabledProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void ManipulationInertiaStartingEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::ManipulationInertiaStartingEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void ManipulationModePropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::ManipulationModeProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void ManipulationStartedEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::ManipulationStartedEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void ManipulationStartingEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::ManipulationStartingEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void OpacityPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::OpacityProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void PointerCanceledEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::PointerCanceledEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void PointerCaptureLostEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::PointerCaptureLostEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void PointerCapturesPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::PointerCapturesProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void PointerEnteredEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::PointerEnteredEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void PointerExitedEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::PointerExitedEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void PointerMovedEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::PointerMovedEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void PointerPressedEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::PointerPressedEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void PointerWheelChangedEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::PointerWheelChangedEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void ProjectionPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::ProjectionProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void RenderTransformOriginPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::RenderTransformOriginProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void RenderTransformPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::RenderTransformProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void RightTappedEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::RightTappedEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void DragEnterEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::DragEnterEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void TappedEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::TappedEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void TransitionsPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::TransitionsProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void UseLayoutRoundingPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::UseLayoutRoundingProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void VisibilityPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::VisibilityProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void AllowDropPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::AllowDropProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void CacheModePropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::CacheModeProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void ClipPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::ClipProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void DoubleTappedEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::DoubleTappedEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void PointerReleasedEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::PointerReleasedEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void DragLeaveEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::DragLeaveEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void DragOverEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::DragOverEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void DropEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::DropEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void ShadowPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::ShadowProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void CompositeModePropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::CompositeModeProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void CanDragPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::CanDragProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void Transform3DPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::Transform3DProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void AccessKeyPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::AccessKeyProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void AccessKeyScopeOwnerPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::AccessKeyScopeOwnerProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void ContextFlyoutPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::ContextFlyoutProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void IsAccessKeyScopePropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::IsAccessKeyScopeProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void ExitDisplayModeOnAccessKeyInvokedPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::ExitDisplayModeOnAccessKeyInvokedProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void HighContrastAdjustmentPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::HighContrastAdjustmentProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void KeyTipHorizontalOffsetPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::KeyTipHorizontalOffsetProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void KeyTipPlacementModePropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::KeyTipPlacementModeProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void KeyTipVerticalOffsetPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::KeyTipVerticalOffsetProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void LightsPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::LightsProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void XYFocusDownNavigationStrategyPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::XYFocusDownNavigationStrategyProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void XYFocusKeyboardNavigationPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::XYFocusKeyboardNavigationProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void XYFocusLeftNavigationStrategyPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::XYFocusLeftNavigationStrategyProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void XYFocusRightNavigationStrategyPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::XYFocusRightNavigationStrategyProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void XYFocusUpNavigationStrategyPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::XYFocusUpNavigationStrategyProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void TabFocusNavigationPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::TabFocusNavigationProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void GettingFocusEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::GettingFocusEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void LosingFocusEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::LosingFocusEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void NoFocusCandidateFoundEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::NoFocusCandidateFoundEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void CharacterReceivedEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::CharacterReceivedEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void PreviewKeyDownEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::PreviewKeyDownEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void PreviewKeyUpEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::PreviewKeyUpEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void BringIntoViewRequestedEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::BringIntoViewRequestedEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void ContextRequestedEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::RoutedEvent^ result = ::Windows::UI::Xaml::UIElement::ContextRequestedEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void KeyTipTargetPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::KeyTipTargetProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void KeyboardAcceleratorPlacementModePropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::KeyboardAcceleratorPlacementModeProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void KeyboardAcceleratorPlacementTargetPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::KeyboardAcceleratorPlacementTargetProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void CanBeScrollAnchorPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::UIElement::CanBeScrollAnchorProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void AddListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"layoutUpdated", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->LayoutUpdated::add(
            ref new ::Windows::Foundation::EventHandler<::Platform::Object^>(
            [callbackObjPtr](::Platform::Object^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"loaded", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->Loaded::add(
            ref new ::Windows::UI::Xaml::RoutedEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::RoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = WrapRoutedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"sizeChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->SizeChanged::add(
            ref new ::Windows::UI::Xaml::SizeChangedEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::SizeChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = WrapSizeChangedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"unloaded", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->Unloaded::add(
            ref new ::Windows::UI::Xaml::RoutedEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::RoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = WrapRoutedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"dataContextChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->DataContextChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::FrameworkElement^, ::Windows::UI::Xaml::DataContextChangedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::FrameworkElement^ arg0, ::Windows::UI::Xaml::DataContextChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapFrameworkElement(arg0);
                  wrappedArg1 = WrapDataContextChangedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"loading", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->Loading::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::FrameworkElement^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::UI::Xaml::FrameworkElement^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapFrameworkElement(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"actualThemeChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->ActualThemeChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::FrameworkElement^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::UI::Xaml::FrameworkElement^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapFrameworkElement(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"effectiveViewportChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->EffectiveViewportChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::FrameworkElement^, ::Windows::UI::Xaml::EffectiveViewportChangedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::FrameworkElement^ arg0, ::Windows::UI::Xaml::EffectiveViewportChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapFrameworkElement(arg0);
                  wrappedArg1 = WrapEffectiveViewportChangedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"doubleTapped", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->DoubleTapped::add(
            ref new ::Windows::UI::Xaml::Input::DoubleTappedEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::DoubleTappedRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "DoubleTappedRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"dragEnter", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->DragEnter::add(
            ref new ::Windows::UI::Xaml::DragEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::DragEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = WrapDragEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"dragLeave", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->DragLeave::add(
            ref new ::Windows::UI::Xaml::DragEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::DragEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = WrapDragEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"dragOver", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->DragOver::add(
            ref new ::Windows::UI::Xaml::DragEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::DragEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = WrapDragEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"drop", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->Drop::add(
            ref new ::Windows::UI::Xaml::DragEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::DragEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = WrapDragEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"gotFocus", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->GotFocus::add(
            ref new ::Windows::UI::Xaml::RoutedEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::RoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = WrapRoutedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"holding", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->Holding::add(
            ref new ::Windows::UI::Xaml::Input::HoldingEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::HoldingRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "HoldingRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"keyDown", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->KeyDown::add(
            ref new ::Windows::UI::Xaml::Input::KeyEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::KeyRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "KeyRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"keyUp", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->KeyUp::add(
            ref new ::Windows::UI::Xaml::Input::KeyEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::KeyRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "KeyRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"lostFocus", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->LostFocus::add(
            ref new ::Windows::UI::Xaml::RoutedEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::RoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = WrapRoutedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"manipulationCompleted", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->ManipulationCompleted::add(
            ref new ::Windows::UI::Xaml::Input::ManipulationCompletedEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::ManipulationCompletedRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "ManipulationCompletedRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"manipulationDelta", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->ManipulationDelta::add(
            ref new ::Windows::UI::Xaml::Input::ManipulationDeltaEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::ManipulationDeltaRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "ManipulationDeltaRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"manipulationInertiaStarting", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->ManipulationInertiaStarting::add(
            ref new ::Windows::UI::Xaml::Input::ManipulationInertiaStartingEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::ManipulationInertiaStartingRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "ManipulationInertiaStartingRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"manipulationStarted", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->ManipulationStarted::add(
            ref new ::Windows::UI::Xaml::Input::ManipulationStartedEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::ManipulationStartedRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "ManipulationStartedRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"manipulationStarting", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->ManipulationStarting::add(
            ref new ::Windows::UI::Xaml::Input::ManipulationStartingEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::ManipulationStartingRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "ManipulationStartingRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerCanceled", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PointerCanceled::add(
            ref new ::Windows::UI::Xaml::Input::PointerEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::PointerRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "PointerRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerCaptureLost", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PointerCaptureLost::add(
            ref new ::Windows::UI::Xaml::Input::PointerEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::PointerRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "PointerRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerEntered", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PointerEntered::add(
            ref new ::Windows::UI::Xaml::Input::PointerEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::PointerRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "PointerRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerExited", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PointerExited::add(
            ref new ::Windows::UI::Xaml::Input::PointerEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::PointerRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "PointerRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerMoved", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PointerMoved::add(
            ref new ::Windows::UI::Xaml::Input::PointerEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::PointerRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "PointerRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerPressed", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PointerPressed::add(
            ref new ::Windows::UI::Xaml::Input::PointerEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::PointerRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "PointerRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerReleased", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PointerReleased::add(
            ref new ::Windows::UI::Xaml::Input::PointerEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::PointerRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "PointerRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerWheelChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PointerWheelChanged::add(
            ref new ::Windows::UI::Xaml::Input::PointerEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::PointerRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "PointerRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"rightTapped", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->RightTapped::add(
            ref new ::Windows::UI::Xaml::Input::RightTappedEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::RightTappedRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "RightTappedRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"tapped", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->Tapped::add(
            ref new ::Windows::UI::Xaml::Input::TappedEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::TappedRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "TappedRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"dragStarting", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->DragStarting::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::UIElement^, ::Windows::UI::Xaml::DragStartingEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::UIElement^ arg0, ::Windows::UI::Xaml::DragStartingEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUIElement(arg0);
                  wrappedArg1 = WrapDragStartingEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"dropCompleted", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->DropCompleted::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::UIElement^, ::Windows::UI::Xaml::DropCompletedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::UIElement^ arg0, ::Windows::UI::Xaml::DropCompletedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUIElement(arg0);
                  wrappedArg1 = WrapDropCompletedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"accessKeyDisplayDismissed", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->AccessKeyDisplayDismissed::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::UIElement^, ::Windows::UI::Xaml::Input::AccessKeyDisplayDismissedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::UIElement^ arg0, ::Windows::UI::Xaml::Input::AccessKeyDisplayDismissedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUIElement(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "AccessKeyDisplayDismissedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"accessKeyDisplayRequested", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->AccessKeyDisplayRequested::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::UIElement^, ::Windows::UI::Xaml::Input::AccessKeyDisplayRequestedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::UIElement^ arg0, ::Windows::UI::Xaml::Input::AccessKeyDisplayRequestedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUIElement(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "AccessKeyDisplayRequestedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"accessKeyInvoked", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->AccessKeyInvoked::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::UIElement^, ::Windows::UI::Xaml::Input::AccessKeyInvokedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::UIElement^ arg0, ::Windows::UI::Xaml::Input::AccessKeyInvokedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUIElement(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "AccessKeyInvokedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"contextCanceled", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->ContextCanceled::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::UIElement^, ::Windows::UI::Xaml::RoutedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::UIElement^ arg0, ::Windows::UI::Xaml::RoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUIElement(arg0);
                  wrappedArg1 = WrapRoutedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"contextRequested", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->ContextRequested::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::UIElement^, ::Windows::UI::Xaml::Input::ContextRequestedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::UIElement^ arg0, ::Windows::UI::Xaml::Input::ContextRequestedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUIElement(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "ContextRequestedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"gettingFocus", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->GettingFocus::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::UIElement^, ::Windows::UI::Xaml::Input::GettingFocusEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::UIElement^ arg0, ::Windows::UI::Xaml::Input::GettingFocusEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUIElement(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "GettingFocusEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"losingFocus", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->LosingFocus::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::UIElement^, ::Windows::UI::Xaml::Input::LosingFocusEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::UIElement^ arg0, ::Windows::UI::Xaml::Input::LosingFocusEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUIElement(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "LosingFocusEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"noFocusCandidateFound", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->NoFocusCandidateFound::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::UIElement^, ::Windows::UI::Xaml::Input::NoFocusCandidateFoundEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::UIElement^ arg0, ::Windows::UI::Xaml::Input::NoFocusCandidateFoundEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUIElement(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "NoFocusCandidateFoundEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"characterReceived", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->CharacterReceived::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::UIElement^, ::Windows::UI::Xaml::Input::CharacterReceivedRoutedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::UIElement^ arg0, ::Windows::UI::Xaml::Input::CharacterReceivedRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUIElement(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "CharacterReceivedRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"previewKeyDown", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PreviewKeyDown::add(
            ref new ::Windows::UI::Xaml::Input::KeyEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::KeyRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "KeyRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"previewKeyUp", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PreviewKeyUp::add(
            ref new ::Windows::UI::Xaml::Input::KeyEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::Input::KeyRoutedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "KeyRoutedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"processKeyboardAccelerators", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->ProcessKeyboardAccelerators::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::UIElement^, ::Windows::UI::Xaml::Input::ProcessKeyboardAcceleratorEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::UIElement^ arg0, ::Windows::UI::Xaml::Input::ProcessKeyboardAcceleratorEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUIElement(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Input", "ProcessKeyboardAcceleratorEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"bringIntoViewRequested", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->BringIntoViewRequested::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::UIElement^, ::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::UIElement^ arg0, ::Windows::UI::Xaml::BringIntoViewRequestedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUIElement(arg0);
                  wrappedArg1 = WrapBringIntoViewRequestedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
 else  {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Value> tokenMapVal = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());
      Local<Object> tokenMap;

      if (tokenMapVal.IsEmpty() || Nan::Equals(tokenMapVal, Undefined()).FromMaybe(false)) {
        tokenMap = Nan::New<Object>();
        NodeRT::Utils::SetHiddenValueWithObject(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked(), tokenMap);
      } else {
        tokenMap = Nan::To<Object>(tokenMapVal).ToLocalChecked();
      }

      Nan::Set(tokenMap, info[0], CreateOpaqueWrapper(::Windows::Foundation::PropertyValue::CreateInt64(registrationToken.Value)));
    }

    static void RemoveListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected a string and a callback")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      if ((!NodeRT::Utils::CaseInsenstiveEquals(L"layoutUpdated", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"loaded", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"sizeChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"unloaded", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"dataContextChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"loading", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"actualThemeChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"effectiveViewportChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"doubleTapped", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"dragEnter", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"dragLeave", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"dragOver", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"drop", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"gotFocus", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"holding", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"keyDown", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"keyUp", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"lostFocus", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"manipulationCompleted", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"manipulationDelta", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"manipulationInertiaStarting", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"manipulationStarted", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"manipulationStarting", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"pointerCanceled", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"pointerCaptureLost", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"pointerEntered", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"pointerExited", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"pointerMoved", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"pointerPressed", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"pointerReleased", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"pointerWheelChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"rightTapped", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"tapped", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"dragStarting", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"dropCompleted", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"accessKeyDisplayDismissed", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"accessKeyDisplayRequested", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"accessKeyInvoked", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"contextCanceled", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"contextRequested", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"gettingFocus", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"losingFocus", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"noFocusCandidateFound", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"characterReceived", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"previewKeyDown", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"previewKeyUp", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"processKeyboardAccelerators", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"bringIntoViewRequested", str))) {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Function> callback = info[1].As<Function>();
      Local<Value> tokenMap = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());

      if (tokenMap.IsEmpty() || Nan::Equals(tokenMap, Undefined()).FromMaybe(false)) {
        return;
      }

      Local<Value> opaqueWrapperObj =  Nan::Get(Nan::To<Object>(tokenMap).ToLocalChecked(), info[0]).ToLocalChecked();

      if (opaqueWrapperObj.IsEmpty() || Nan::Equals(opaqueWrapperObj,Undefined()).FromMaybe(false)) {
        return;
      }

      OpaqueWrapper *opaqueWrapper = OpaqueWrapper::Unwrap<OpaqueWrapper>(opaqueWrapperObj.As<Object>());

      long long tokenValue = (long long) opaqueWrapper->GetObjectInstance();
      ::Windows::Foundation::EventRegistrationToken registrationToken;
      registrationToken.Value = tokenValue;

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"layoutUpdated", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->LayoutUpdated::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"loaded", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->Loaded::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"sizeChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->SizeChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"unloaded", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->Unloaded::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"dataContextChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->DataContextChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"loading", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->Loading::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"actualThemeChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->ActualThemeChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"effectiveViewportChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->EffectiveViewportChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"doubleTapped", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->DoubleTapped::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"dragEnter", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->DragEnter::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"dragLeave", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->DragLeave::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"dragOver", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->DragOver::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"drop", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->Drop::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"gotFocus", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->GotFocus::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"holding", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->Holding::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"keyDown", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->KeyDown::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"keyUp", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->KeyUp::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"lostFocus", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->LostFocus::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"manipulationCompleted", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->ManipulationCompleted::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"manipulationDelta", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->ManipulationDelta::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"manipulationInertiaStarting", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->ManipulationInertiaStarting::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"manipulationStarted", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->ManipulationStarted::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"manipulationStarting", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->ManipulationStarting::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerCanceled", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->PointerCanceled::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerCaptureLost", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->PointerCaptureLost::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerEntered", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->PointerEntered::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerExited", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->PointerExited::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerMoved", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->PointerMoved::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerPressed", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->PointerPressed::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerReleased", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->PointerReleased::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerWheelChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->PointerWheelChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"rightTapped", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->RightTapped::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"tapped", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->Tapped::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"dragStarting", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->DragStarting::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"dropCompleted", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->DropCompleted::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"accessKeyDisplayDismissed", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->AccessKeyDisplayDismissed::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"accessKeyDisplayRequested", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->AccessKeyDisplayRequested::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"accessKeyInvoked", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->AccessKeyInvoked::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"contextCanceled", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->ContextCanceled::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"contextRequested", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->ContextRequested::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"gettingFocus", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->GettingFocus::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"losingFocus", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->LosingFocus::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"noFocusCandidateFound", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->NoFocusCandidateFound::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"characterReceived", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->CharacterReceived::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"previewKeyDown", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->PreviewKeyDown::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"previewKeyUp", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->PreviewKeyUp::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"processKeyboardAccelerators", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->ProcessKeyboardAccelerators::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"bringIntoViewRequested", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          FrameworkElement *wrapper = FrameworkElement::Unwrap<FrameworkElement>(info.This());
          wrapper->_instance->BringIntoViewRequested::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

      Nan::Delete(Nan::To<Object>(tokenMap).ToLocalChecked(), Nan::To<String>(info[0]).ToLocalChecked());
    }
    private:
      ::Windows::UI::Xaml::FrameworkElement^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapFrameworkElement(::Windows::UI::Xaml::FrameworkElement^ wintRtInstance);
      friend ::Windows::UI::Xaml::FrameworkElement^ UnwrapFrameworkElement(Local<Value> value);
  };

  Persistent<FunctionTemplate> FrameworkElement::s_constructorTemplate;

  v8::Local<v8::Value> WrapFrameworkElement(::Windows::UI::Xaml::FrameworkElement^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(FrameworkElement::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::FrameworkElement^ UnwrapFrameworkElement(Local<Value> value) {
     return FrameworkElement::Unwrap<FrameworkElement>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitFrameworkElement(Local<Object> exports) {
    FrameworkElement::Init(exports);
  }

  class FrameworkTemplate : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("FrameworkTemplate").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("FrameworkTemplate").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      FrameworkTemplate(::Windows::UI::Xaml::FrameworkTemplate^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::FrameworkTemplate^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkTemplate^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::FrameworkTemplate^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      FrameworkTemplate *wrapperInstance = new FrameworkTemplate(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkTemplate^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::FrameworkTemplate^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::FrameworkTemplate^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapFrameworkTemplate(winRtInstance));
    }





    static void DispatcherGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      try  {
        ::Windows::UI::Core::CoreDispatcher^ result = wrapper->_instance->Dispatcher;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "CoreDispatcher", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::FrameworkTemplate^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapFrameworkTemplate(::Windows::UI::Xaml::FrameworkTemplate^ wintRtInstance);
      friend ::Windows::UI::Xaml::FrameworkTemplate^ UnwrapFrameworkTemplate(Local<Value> value);
  };

  Persistent<FunctionTemplate> FrameworkTemplate::s_constructorTemplate;

  v8::Local<v8::Value> WrapFrameworkTemplate(::Windows::UI::Xaml::FrameworkTemplate^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(FrameworkTemplate::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::FrameworkTemplate^ UnwrapFrameworkTemplate(Local<Value> value) {
     return FrameworkTemplate::Unwrap<FrameworkTemplate>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitFrameworkTemplate(Local<Object> exports) {
    FrameworkTemplate::Init(exports);
  }

  class DataContextChangedEventArgs : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("DataContextChangedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("handled").ToLocalChecked(), HandledGetter, HandledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("newValue").ToLocalChecked(), NewValueGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("DataContextChangedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      DataContextChangedEventArgs(::Windows::UI::Xaml::DataContextChangedEventArgs^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::DataContextChangedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DataContextChangedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::DataContextChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      DataContextChangedEventArgs *wrapperInstance = new DataContextChangedEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DataContextChangedEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::DataContextChangedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::DataContextChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapDataContextChangedEventArgs(winRtInstance));
    }





    static void HandledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DataContextChangedEventArgs^>(info.This())) {
        return;
      }

      DataContextChangedEventArgs *wrapper = DataContextChangedEventArgs::Unwrap<DataContextChangedEventArgs>(info.This());

      try  {
        bool result = wrapper->_instance->Handled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void HandledSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DataContextChangedEventArgs^>(info.This())) {
        return;
      }

      DataContextChangedEventArgs *wrapper = DataContextChangedEventArgs::Unwrap<DataContextChangedEventArgs>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->Handled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void NewValueGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DataContextChangedEventArgs^>(info.This())) {
        return;
      }

      DataContextChangedEventArgs *wrapper = DataContextChangedEventArgs::Unwrap<DataContextChangedEventArgs>(info.This());

      try  {
        ::Platform::Object^ result = wrapper->_instance->NewValue;
        info.GetReturnValue().Set(CreateOpaqueWrapper(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::DataContextChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapDataContextChangedEventArgs(::Windows::UI::Xaml::DataContextChangedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Xaml::DataContextChangedEventArgs^ UnwrapDataContextChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> DataContextChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapDataContextChangedEventArgs(::Windows::UI::Xaml::DataContextChangedEventArgs^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(DataContextChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::DataContextChangedEventArgs^ UnwrapDataContextChangedEventArgs(Local<Value> value) {
     return DataContextChangedEventArgs::Unwrap<DataContextChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitDataContextChangedEventArgs(Local<Object> exports) {
    DataContextChangedEventArgs::Init(exports);
  }

  class DataTemplate : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("DataTemplate").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "loadContent", LoadContent);
            Nan::SetPrototypeMethod(localRef, "getElement", GetElement);
            Nan::SetPrototypeMethod(localRef, "recycleElement", RecycleElement);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetMethod(constructor, "getExtensionInstance", GetExtensionInstance);
        Nan::SetMethod(constructor, "setExtensionInstance", SetExtensionInstance);
        Nan::SetAccessor(constructor, Nan::New<String>("extensionInstanceProperty").ToLocalChecked(), ExtensionInstancePropertyGetter);


        Nan::Set(exports, Nan::New<String>("DataTemplate").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      DataTemplate(::Windows::UI::Xaml::DataTemplate^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::DataTemplate^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DataTemplate^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::DataTemplate^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::DataTemplate();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      DataTemplate *wrapperInstance = new DataTemplate(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DataTemplate^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::DataTemplate^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::DataTemplate^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapDataTemplate(winRtInstance));
    }


    static void LoadContent(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DataTemplate^>(info.This())) {
        return;
      }

      DataTemplate *wrapper = DataTemplate::Unwrap<DataTemplate>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::UI::Xaml::DependencyObject^ result;
          result = wrapper->_instance->LoadContent();
          info.GetReturnValue().Set(WrapDependencyObject(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetElement(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DataTemplate^>(info.This())) {
        return;
      }

      DataTemplate *wrapper = DataTemplate::Unwrap<DataTemplate>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ElementFactoryGetArgs^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::ElementFactoryGetArgs^ arg0 = UnwrapElementFactoryGetArgs(info[0]);
          
          ::Windows::UI::Xaml::UIElement^ result;
          result = wrapper->_instance->GetElement(arg0);
          info.GetReturnValue().Set(WrapUIElement(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void RecycleElement(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DataTemplate^>(info.This())) {
        return;
      }

      DataTemplate *wrapper = DataTemplate::Unwrap<DataTemplate>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ElementFactoryRecycleArgs^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::ElementFactoryRecycleArgs^ arg0 = UnwrapElementFactoryRecycleArgs(info[0]);
          
          wrapper->_instance->RecycleElement(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    static void GetExtensionInstance(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::FrameworkElement^ arg0 = UnwrapFrameworkElement(info[0]);
          
          ::Windows::UI::Xaml::IDataTemplateExtension^ result;
          result = ::Windows::UI::Xaml::DataTemplate::GetExtensionInstance(arg0);
          info.GetReturnValue().Set(WrapIDataTemplateExtension(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void SetExtensionInstance(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::IDataTemplateExtension^>(info[1]))
      {
        try
        {
          ::Windows::UI::Xaml::FrameworkElement^ arg0 = UnwrapFrameworkElement(info[0]);
          ::Windows::UI::Xaml::IDataTemplateExtension^ arg1 = UnwrapIDataTemplateExtension(info[1]);
          
          ::Windows::UI::Xaml::DataTemplate::SetExtensionInstance(arg0, arg1);
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void DispatcherGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      try  {
        ::Windows::UI::Core::CoreDispatcher^ result = wrapper->_instance->Dispatcher;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "CoreDispatcher", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    static void ExtensionInstancePropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::DataTemplate::ExtensionInstanceProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    private:
      ::Windows::UI::Xaml::DataTemplate^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapDataTemplate(::Windows::UI::Xaml::DataTemplate^ wintRtInstance);
      friend ::Windows::UI::Xaml::DataTemplate^ UnwrapDataTemplate(Local<Value> value);
  };

  Persistent<FunctionTemplate> DataTemplate::s_constructorTemplate;

  v8::Local<v8::Value> WrapDataTemplate(::Windows::UI::Xaml::DataTemplate^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(DataTemplate::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::DataTemplate^ UnwrapDataTemplate(Local<Value> value) {
     return DataTemplate::Unwrap<DataTemplate>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitDataTemplate(Local<Object> exports) {
    DataTemplate::Init(exports);
  }

  class DataTemplateKey : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("DataTemplateKey").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dataType").ToLocalChecked(), DataTypeGetter, DataTypeSetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("DataTemplateKey").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      DataTemplateKey(::Windows::UI::Xaml::DataTemplateKey^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::DataTemplateKey^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DataTemplateKey^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::DataTemplateKey^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::DataTemplateKey();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[0]))
      {
        try {
          ::Platform::Object^ arg0 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          winRtInstance = ref new ::Windows::UI::Xaml::DataTemplateKey(arg0);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      DataTemplateKey *wrapperInstance = new DataTemplateKey(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DataTemplateKey^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::DataTemplateKey^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::DataTemplateKey^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapDataTemplateKey(winRtInstance));
    }





    static void DataTypeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DataTemplateKey^>(info.This())) {
        return;
      }

      DataTemplateKey *wrapper = DataTemplateKey::Unwrap<DataTemplateKey>(info.This());

      try  {
        ::Platform::Object^ result = wrapper->_instance->DataType;
        info.GetReturnValue().Set(CreateOpaqueWrapper(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DataTypeSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DataTemplateKey^>(info.This())) {
        return;
      }

      DataTemplateKey *wrapper = DataTemplateKey::Unwrap<DataTemplateKey>(info.This());

      try {

        ::Platform::Object^ winRtValue = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->DataType = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      


    private:
      ::Windows::UI::Xaml::DataTemplateKey^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapDataTemplateKey(::Windows::UI::Xaml::DataTemplateKey^ wintRtInstance);
      friend ::Windows::UI::Xaml::DataTemplateKey^ UnwrapDataTemplateKey(Local<Value> value);
  };

  Persistent<FunctionTemplate> DataTemplateKey::s_constructorTemplate;

  v8::Local<v8::Value> WrapDataTemplateKey(::Windows::UI::Xaml::DataTemplateKey^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(DataTemplateKey::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::DataTemplateKey^ UnwrapDataTemplateKey(Local<Value> value) {
     return DataTemplateKey::Unwrap<DataTemplateKey>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitDataTemplateKey(Local<Object> exports) {
    DataTemplateKey::Init(exports);
  }

  class DebugSettings : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("DebugSettings").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);




          
          Nan::SetPrototypeMethod(localRef,"addListener", AddListener);
          Nan::SetPrototypeMethod(localRef,"on", AddListener);
          Nan::SetPrototypeMethod(localRef,"removeListener", RemoveListener);
          Nan::SetPrototypeMethod(localRef, "off", RemoveListener);

          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isOverdrawHeatMapEnabled").ToLocalChecked(), IsOverdrawHeatMapEnabledGetter, IsOverdrawHeatMapEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isBindingTracingEnabled").ToLocalChecked(), IsBindingTracingEnabledGetter, IsBindingTracingEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("enableFrameRateCounter").ToLocalChecked(), EnableFrameRateCounterGetter, EnableFrameRateCounterSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("enableRedrawRegions").ToLocalChecked(), EnableRedrawRegionsGetter, EnableRedrawRegionsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isTextPerformanceVisualizationEnabled").ToLocalChecked(), IsTextPerformanceVisualizationEnabledGetter, IsTextPerformanceVisualizationEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("failFastOnErrors").ToLocalChecked(), FailFastOnErrorsGetter, FailFastOnErrorsSetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("DebugSettings").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      DebugSettings(::Windows::UI::Xaml::DebugSettings^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::DebugSettings^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DebugSettings^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::DebugSettings^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      DebugSettings *wrapperInstance = new DebugSettings(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DebugSettings^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::DebugSettings^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::DebugSettings^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapDebugSettings(winRtInstance));
    }





    static void IsOverdrawHeatMapEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DebugSettings^>(info.This())) {
        return;
      }

      DebugSettings *wrapper = DebugSettings::Unwrap<DebugSettings>(info.This());

      try  {
        bool result = wrapper->_instance->IsOverdrawHeatMapEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsOverdrawHeatMapEnabledSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DebugSettings^>(info.This())) {
        return;
      }

      DebugSettings *wrapper = DebugSettings::Unwrap<DebugSettings>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsOverdrawHeatMapEnabled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsBindingTracingEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DebugSettings^>(info.This())) {
        return;
      }

      DebugSettings *wrapper = DebugSettings::Unwrap<DebugSettings>(info.This());

      try  {
        bool result = wrapper->_instance->IsBindingTracingEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsBindingTracingEnabledSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DebugSettings^>(info.This())) {
        return;
      }

      DebugSettings *wrapper = DebugSettings::Unwrap<DebugSettings>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsBindingTracingEnabled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void EnableFrameRateCounterGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DebugSettings^>(info.This())) {
        return;
      }

      DebugSettings *wrapper = DebugSettings::Unwrap<DebugSettings>(info.This());

      try  {
        bool result = wrapper->_instance->EnableFrameRateCounter;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void EnableFrameRateCounterSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DebugSettings^>(info.This())) {
        return;
      }

      DebugSettings *wrapper = DebugSettings::Unwrap<DebugSettings>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->EnableFrameRateCounter = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void EnableRedrawRegionsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DebugSettings^>(info.This())) {
        return;
      }

      DebugSettings *wrapper = DebugSettings::Unwrap<DebugSettings>(info.This());

      try  {
        bool result = wrapper->_instance->EnableRedrawRegions;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void EnableRedrawRegionsSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DebugSettings^>(info.This())) {
        return;
      }

      DebugSettings *wrapper = DebugSettings::Unwrap<DebugSettings>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->EnableRedrawRegions = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsTextPerformanceVisualizationEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DebugSettings^>(info.This())) {
        return;
      }

      DebugSettings *wrapper = DebugSettings::Unwrap<DebugSettings>(info.This());

      try  {
        bool result = wrapper->_instance->IsTextPerformanceVisualizationEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsTextPerformanceVisualizationEnabledSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DebugSettings^>(info.This())) {
        return;
      }

      DebugSettings *wrapper = DebugSettings::Unwrap<DebugSettings>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsTextPerformanceVisualizationEnabled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void FailFastOnErrorsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DebugSettings^>(info.This())) {
        return;
      }

      DebugSettings *wrapper = DebugSettings::Unwrap<DebugSettings>(info.This());

      try  {
        bool result = wrapper->_instance->FailFastOnErrors;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void FailFastOnErrorsSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DebugSettings^>(info.This())) {
        return;
      }

      DebugSettings *wrapper = DebugSettings::Unwrap<DebugSettings>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->FailFastOnErrors = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      


    static void AddListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"bindingFailed", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DebugSettings^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        DebugSettings *wrapper = DebugSettings::Unwrap<DebugSettings>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->BindingFailed::add(
            ref new ::Windows::UI::Xaml::BindingFailedEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::BindingFailedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = WrapBindingFailedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
 else  {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Value> tokenMapVal = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());
      Local<Object> tokenMap;

      if (tokenMapVal.IsEmpty() || Nan::Equals(tokenMapVal, Undefined()).FromMaybe(false)) {
        tokenMap = Nan::New<Object>();
        NodeRT::Utils::SetHiddenValueWithObject(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked(), tokenMap);
      } else {
        tokenMap = Nan::To<Object>(tokenMapVal).ToLocalChecked();
      }

      Nan::Set(tokenMap, info[0], CreateOpaqueWrapper(::Windows::Foundation::PropertyValue::CreateInt64(registrationToken.Value)));
    }

    static void RemoveListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected a string and a callback")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      if ((!NodeRT::Utils::CaseInsenstiveEquals(L"bindingFailed", str))) {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Function> callback = info[1].As<Function>();
      Local<Value> tokenMap = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());

      if (tokenMap.IsEmpty() || Nan::Equals(tokenMap, Undefined()).FromMaybe(false)) {
        return;
      }

      Local<Value> opaqueWrapperObj =  Nan::Get(Nan::To<Object>(tokenMap).ToLocalChecked(), info[0]).ToLocalChecked();

      if (opaqueWrapperObj.IsEmpty() || Nan::Equals(opaqueWrapperObj,Undefined()).FromMaybe(false)) {
        return;
      }

      OpaqueWrapper *opaqueWrapper = OpaqueWrapper::Unwrap<OpaqueWrapper>(opaqueWrapperObj.As<Object>());

      long long tokenValue = (long long) opaqueWrapper->GetObjectInstance();
      ::Windows::Foundation::EventRegistrationToken registrationToken;
      registrationToken.Value = tokenValue;

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"bindingFailed", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DebugSettings^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          DebugSettings *wrapper = DebugSettings::Unwrap<DebugSettings>(info.This());
          wrapper->_instance->BindingFailed::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

      Nan::Delete(Nan::To<Object>(tokenMap).ToLocalChecked(), Nan::To<String>(info[0]).ToLocalChecked());
    }
    private:
      ::Windows::UI::Xaml::DebugSettings^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapDebugSettings(::Windows::UI::Xaml::DebugSettings^ wintRtInstance);
      friend ::Windows::UI::Xaml::DebugSettings^ UnwrapDebugSettings(Local<Value> value);
  };

  Persistent<FunctionTemplate> DebugSettings::s_constructorTemplate;

  v8::Local<v8::Value> WrapDebugSettings(::Windows::UI::Xaml::DebugSettings^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(DebugSettings::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::DebugSettings^ UnwrapDebugSettings(Local<Value> value) {
     return DebugSettings::Unwrap<DebugSettings>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitDebugSettings(Local<Object> exports) {
    DebugSettings::Init(exports);
  }

  class DependencyObjectCollection : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("DependencyObjectCollection").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "getAt", GetAt);
            Nan::SetPrototypeMethod(localRef, "getView", GetView);
            Nan::SetPrototypeMethod(localRef, "indexOf", IndexOf);
            Nan::SetPrototypeMethod(localRef, "setAt", SetAt);
            Nan::SetPrototypeMethod(localRef, "insertAt", InsertAt);
            Nan::SetPrototypeMethod(localRef, "removeAt", RemoveAt);
            Nan::SetPrototypeMethod(localRef, "append", Append);
            Nan::SetPrototypeMethod(localRef, "removeAtEnd", RemoveAtEnd);
            Nan::SetPrototypeMethod(localRef, "clear", Clear);
            Nan::SetPrototypeMethod(localRef, "getMany", GetMany);
            Nan::SetPrototypeMethod(localRef, "replaceAll", ReplaceAll);
            Nan::SetPrototypeMethod(localRef, "first", First);
          


          
          Nan::SetPrototypeMethod(localRef,"addListener", AddListener);
          Nan::SetPrototypeMethod(localRef,"on", AddListener);
          Nan::SetPrototypeMethod(localRef,"removeListener", RemoveListener);
          Nan::SetPrototypeMethod(localRef, "off", RemoveListener);

          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("DependencyObjectCollection").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      DependencyObjectCollection(::Windows::UI::Xaml::DependencyObjectCollection^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::DependencyObjectCollection^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObjectCollection^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::DependencyObjectCollection^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::DependencyObjectCollection();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      DependencyObjectCollection *wrapperInstance = new DependencyObjectCollection(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObjectCollection^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::DependencyObjectCollection^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::DependencyObjectCollection^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapDependencyObjectCollection(winRtInstance));
    }


    static void GetAt(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObjectCollection^>(info.This())) {
        return;
      }

      DependencyObjectCollection *wrapper = DependencyObjectCollection::Unwrap<DependencyObjectCollection>(info.This());

      if (info.Length() == 1
        && info[0]->IsUint32())
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          
          ::Windows::UI::Xaml::DependencyObject^ result;
          result = wrapper->_instance->GetAt(arg0);
          info.GetReturnValue().Set(WrapDependencyObject(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetView(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObjectCollection^>(info.This())) {
        return;
      }

      DependencyObjectCollection *wrapper = DependencyObjectCollection::Unwrap<DependencyObjectCollection>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Xaml::DependencyObject^>^ result;
          result = wrapper->_instance->GetView();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Xaml::DependencyObject^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Xaml::DependencyObject^ val) -> Local<Value> {
              return WrapDependencyObject(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Xaml::DependencyObject^ {
              return UnwrapDependencyObject(value);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void IndexOf(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObjectCollection^>(info.This())) {
        return;
      }

      DependencyObjectCollection *wrapper = DependencyObjectCollection::Unwrap<DependencyObjectCollection>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::DependencyObject^ arg0 = UnwrapDependencyObject(info[0]);
          unsigned int arg1;
          
          bool result;
          result = wrapper->_instance->IndexOf(arg0, &arg1);
          Local<Object> resObj = Nan::New<Object>();
          Nan::Set(resObj, Nan::New<String>("boolean").ToLocalChecked(), Nan::New<Boolean>(result));
          Nan::Set(resObj, Nan::New<String>("index").ToLocalChecked(), Nan::New<Integer>(arg1));
          info.GetReturnValue().Set(resObj);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void SetAt(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObjectCollection^>(info.This())) {
        return;
      }

      DependencyObjectCollection *wrapper = DependencyObjectCollection::Unwrap<DependencyObjectCollection>(info.This());

      if (info.Length() == 2
        && info[0]->IsUint32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info[1]))
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          ::Windows::UI::Xaml::DependencyObject^ arg1 = UnwrapDependencyObject(info[1]);
          
          wrapper->_instance->SetAt(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void InsertAt(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObjectCollection^>(info.This())) {
        return;
      }

      DependencyObjectCollection *wrapper = DependencyObjectCollection::Unwrap<DependencyObjectCollection>(info.This());

      if (info.Length() == 2
        && info[0]->IsUint32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info[1]))
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          ::Windows::UI::Xaml::DependencyObject^ arg1 = UnwrapDependencyObject(info[1]);
          
          wrapper->_instance->InsertAt(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void RemoveAt(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObjectCollection^>(info.This())) {
        return;
      }

      DependencyObjectCollection *wrapper = DependencyObjectCollection::Unwrap<DependencyObjectCollection>(info.This());

      if (info.Length() == 1
        && info[0]->IsUint32())
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          
          wrapper->_instance->RemoveAt(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Append(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObjectCollection^>(info.This())) {
        return;
      }

      DependencyObjectCollection *wrapper = DependencyObjectCollection::Unwrap<DependencyObjectCollection>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::DependencyObject^ arg0 = UnwrapDependencyObject(info[0]);
          
          wrapper->_instance->Append(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void RemoveAtEnd(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObjectCollection^>(info.This())) {
        return;
      }

      DependencyObjectCollection *wrapper = DependencyObjectCollection::Unwrap<DependencyObjectCollection>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->RemoveAtEnd();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Clear(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObjectCollection^>(info.This())) {
        return;
      }

      DependencyObjectCollection *wrapper = DependencyObjectCollection::Unwrap<DependencyObjectCollection>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->Clear();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetMany(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Not implemented")));
    }
    static void ReplaceAll(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObjectCollection^>(info.This())) {
        return;
      }

      DependencyObjectCollection *wrapper = DependencyObjectCollection::Unwrap<DependencyObjectCollection>(info.This());

      if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<::Windows::UI::Xaml::DependencyObject^>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Platform::Array<::Windows::UI::Xaml::DependencyObject^>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<::Windows::UI::Xaml::DependencyObject^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<::Windows::UI::Xaml::DependencyObject^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::UI::Xaml::DependencyObject^ {
                   return UnwrapDependencyObject(value);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<::Windows::UI::Xaml::DependencyObject^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          wrapper->_instance->ReplaceAll(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void First(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObjectCollection^>(info.This())) {
        return;
      }

      DependencyObjectCollection *wrapper = DependencyObjectCollection::Unwrap<DependencyObjectCollection>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IIterator<::Windows::UI::Xaml::DependencyObject^>^ result;
          result = wrapper->_instance->First();
          info.GetReturnValue().Set(NodeRT::Collections::IteratorWrapper<::Windows::UI::Xaml::DependencyObject^>::CreateIteratorWrapper(result, 
            [](::Windows::UI::Xaml::DependencyObject^ val) -> Local<Value> {
              return WrapDependencyObject(val);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    static void DispatcherGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      try  {
        ::Windows::UI::Core::CoreDispatcher^ result = wrapper->_instance->Dispatcher;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "CoreDispatcher", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    static void AddListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"vectorChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObjectCollection^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        DependencyObjectCollection *wrapper = DependencyObjectCollection::Unwrap<DependencyObjectCollection>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->VectorChanged::add(
            ref new ::Windows::Foundation::Collections::VectorChangedEventHandler<::Windows::UI::Xaml::DependencyObject^>(
            [callbackObjPtr](::Windows::Foundation::Collections::IObservableVector<::Windows::UI::Xaml::DependencyObject^>^ arg0, ::Windows::Foundation::Collections::IVectorChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation.Collections", "IObservableVector`1", arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation.Collections", "IVectorChangedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
 else  {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Value> tokenMapVal = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());
      Local<Object> tokenMap;

      if (tokenMapVal.IsEmpty() || Nan::Equals(tokenMapVal, Undefined()).FromMaybe(false)) {
        tokenMap = Nan::New<Object>();
        NodeRT::Utils::SetHiddenValueWithObject(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked(), tokenMap);
      } else {
        tokenMap = Nan::To<Object>(tokenMapVal).ToLocalChecked();
      }

      Nan::Set(tokenMap, info[0], CreateOpaqueWrapper(::Windows::Foundation::PropertyValue::CreateInt64(registrationToken.Value)));
    }

    static void RemoveListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected a string and a callback")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      if ((!NodeRT::Utils::CaseInsenstiveEquals(L"vectorChanged", str))) {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Function> callback = info[1].As<Function>();
      Local<Value> tokenMap = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());

      if (tokenMap.IsEmpty() || Nan::Equals(tokenMap, Undefined()).FromMaybe(false)) {
        return;
      }

      Local<Value> opaqueWrapperObj =  Nan::Get(Nan::To<Object>(tokenMap).ToLocalChecked(), info[0]).ToLocalChecked();

      if (opaqueWrapperObj.IsEmpty() || Nan::Equals(opaqueWrapperObj,Undefined()).FromMaybe(false)) {
        return;
      }

      OpaqueWrapper *opaqueWrapper = OpaqueWrapper::Unwrap<OpaqueWrapper>(opaqueWrapperObj.As<Object>());

      long long tokenValue = (long long) opaqueWrapper->GetObjectInstance();
      ::Windows::Foundation::EventRegistrationToken registrationToken;
      registrationToken.Value = tokenValue;

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"vectorChanged", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObjectCollection^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          DependencyObjectCollection *wrapper = DependencyObjectCollection::Unwrap<DependencyObjectCollection>(info.This());
          wrapper->_instance->VectorChanged::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

      Nan::Delete(Nan::To<Object>(tokenMap).ToLocalChecked(), Nan::To<String>(info[0]).ToLocalChecked());
    }
    private:
      ::Windows::UI::Xaml::DependencyObjectCollection^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapDependencyObjectCollection(::Windows::UI::Xaml::DependencyObjectCollection^ wintRtInstance);
      friend ::Windows::UI::Xaml::DependencyObjectCollection^ UnwrapDependencyObjectCollection(Local<Value> value);
  };

  Persistent<FunctionTemplate> DependencyObjectCollection::s_constructorTemplate;

  v8::Local<v8::Value> WrapDependencyObjectCollection(::Windows::UI::Xaml::DependencyObjectCollection^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(DependencyObjectCollection::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::DependencyObjectCollection^ UnwrapDependencyObjectCollection(Local<Value> value) {
     return DependencyObjectCollection::Unwrap<DependencyObjectCollection>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitDependencyObjectCollection(Local<Object> exports) {
    DependencyObjectCollection::Init(exports);
  }

  class DependencyProperty : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("DependencyProperty").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "getMetadata", GetMetadata);
          




        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetMethod(constructor, "register", Register);
        Nan::SetMethod(constructor, "registerAttached", RegisterAttached);
        Nan::SetAccessor(constructor, Nan::New<String>("unsetValue").ToLocalChecked(), UnsetValueGetter);


        Nan::Set(exports, Nan::New<String>("DependencyProperty").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      DependencyProperty(::Windows::UI::Xaml::DependencyProperty^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::DependencyProperty^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyProperty^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::DependencyProperty^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      DependencyProperty *wrapperInstance = new DependencyProperty(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyProperty^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::DependencyProperty^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::DependencyProperty^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapDependencyProperty(winRtInstance));
    }


    static void GetMetadata(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyProperty^>(info.This())) {
        return;
      }

      DependencyProperty *wrapper = DependencyProperty::Unwrap<DependencyProperty>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Type^>(info[0]))
      {
        try
        {
          ::Platform::Type^ arg0 = dynamic_cast<::Platform::Type^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::UI::Xaml::PropertyMetadata^ result;
          result = wrapper->_instance->GetMetadata(arg0);
          info.GetReturnValue().Set(WrapPropertyMetadata(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    static void Register(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 4
        && info[0]->IsString()
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Type^>(info[1])
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Type^>(info[2])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::PropertyMetadata^>(info[3]))
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Platform::Type^ arg1 = dynamic_cast<::Platform::Type^>(NodeRT::Utils::GetObjectInstance(info[1]));
          ::Platform::Type^ arg2 = dynamic_cast<::Platform::Type^>(NodeRT::Utils::GetObjectInstance(info[2]));
          ::Windows::UI::Xaml::PropertyMetadata^ arg3 = UnwrapPropertyMetadata(info[3]);
          
          ::Windows::UI::Xaml::DependencyProperty^ result;
          result = ::Windows::UI::Xaml::DependencyProperty::Register(arg0, arg1, arg2, arg3);
          info.GetReturnValue().Set(WrapDependencyProperty(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void RegisterAttached(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 4
        && info[0]->IsString()
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Type^>(info[1])
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Type^>(info[2])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::PropertyMetadata^>(info[3]))
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Platform::Type^ arg1 = dynamic_cast<::Platform::Type^>(NodeRT::Utils::GetObjectInstance(info[1]));
          ::Platform::Type^ arg2 = dynamic_cast<::Platform::Type^>(NodeRT::Utils::GetObjectInstance(info[2]));
          ::Windows::UI::Xaml::PropertyMetadata^ arg3 = UnwrapPropertyMetadata(info[3]);
          
          ::Windows::UI::Xaml::DependencyProperty^ result;
          result = ::Windows::UI::Xaml::DependencyProperty::RegisterAttached(arg0, arg1, arg2, arg3);
          info.GetReturnValue().Set(WrapDependencyProperty(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    static void UnsetValueGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Platform::Object^ result = ::Windows::UI::Xaml::DependencyProperty::UnsetValue;
        info.GetReturnValue().Set(CreateOpaqueWrapper(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    private:
      ::Windows::UI::Xaml::DependencyProperty^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapDependencyProperty(::Windows::UI::Xaml::DependencyProperty^ wintRtInstance);
      friend ::Windows::UI::Xaml::DependencyProperty^ UnwrapDependencyProperty(Local<Value> value);
  };

  Persistent<FunctionTemplate> DependencyProperty::s_constructorTemplate;

  v8::Local<v8::Value> WrapDependencyProperty(::Windows::UI::Xaml::DependencyProperty^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(DependencyProperty::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::DependencyProperty^ UnwrapDependencyProperty(Local<Value> value) {
     return DependencyProperty::Unwrap<DependencyProperty>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitDependencyProperty(Local<Object> exports) {
    DependencyProperty::Init(exports);
  }

  class DependencyPropertyChangedEventArgs : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("DependencyPropertyChangedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("newValue").ToLocalChecked(), NewValueGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("oldValue").ToLocalChecked(), OldValueGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("property").ToLocalChecked(), PropertyGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("DependencyPropertyChangedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      DependencyPropertyChangedEventArgs(::Windows::UI::Xaml::DependencyPropertyChangedEventArgs^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::DependencyPropertyChangedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyPropertyChangedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::DependencyPropertyChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      DependencyPropertyChangedEventArgs *wrapperInstance = new DependencyPropertyChangedEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyPropertyChangedEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::DependencyPropertyChangedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::DependencyPropertyChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapDependencyPropertyChangedEventArgs(winRtInstance));
    }





    static void NewValueGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyPropertyChangedEventArgs^>(info.This())) {
        return;
      }

      DependencyPropertyChangedEventArgs *wrapper = DependencyPropertyChangedEventArgs::Unwrap<DependencyPropertyChangedEventArgs>(info.This());

      try  {
        ::Platform::Object^ result = wrapper->_instance->NewValue;
        info.GetReturnValue().Set(CreateOpaqueWrapper(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void OldValueGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyPropertyChangedEventArgs^>(info.This())) {
        return;
      }

      DependencyPropertyChangedEventArgs *wrapper = DependencyPropertyChangedEventArgs::Unwrap<DependencyPropertyChangedEventArgs>(info.This());

      try  {
        ::Platform::Object^ result = wrapper->_instance->OldValue;
        info.GetReturnValue().Set(CreateOpaqueWrapper(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyPropertyChangedEventArgs^>(info.This())) {
        return;
      }

      DependencyPropertyChangedEventArgs *wrapper = DependencyPropertyChangedEventArgs::Unwrap<DependencyPropertyChangedEventArgs>(info.This());

      try  {
        ::Windows::UI::Xaml::DependencyProperty^ result = wrapper->_instance->Property;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::DependencyPropertyChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapDependencyPropertyChangedEventArgs(::Windows::UI::Xaml::DependencyPropertyChangedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Xaml::DependencyPropertyChangedEventArgs^ UnwrapDependencyPropertyChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> DependencyPropertyChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapDependencyPropertyChangedEventArgs(::Windows::UI::Xaml::DependencyPropertyChangedEventArgs^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(DependencyPropertyChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::DependencyPropertyChangedEventArgs^ UnwrapDependencyPropertyChangedEventArgs(Local<Value> value) {
     return DependencyPropertyChangedEventArgs::Unwrap<DependencyPropertyChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitDependencyPropertyChangedEventArgs(Local<Object> exports) {
    DependencyPropertyChangedEventArgs::Init(exports);
  }

  class DispatcherTimer : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("DispatcherTimer").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "start", Start);
            Nan::SetPrototypeMethod(localRef, "stop", Stop);
          


          
          Nan::SetPrototypeMethod(localRef,"addListener", AddListener);
          Nan::SetPrototypeMethod(localRef,"on", AddListener);
          Nan::SetPrototypeMethod(localRef,"removeListener", RemoveListener);
          Nan::SetPrototypeMethod(localRef, "off", RemoveListener);

          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("interval").ToLocalChecked(), IntervalGetter, IntervalSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isEnabled").ToLocalChecked(), IsEnabledGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("DispatcherTimer").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      DispatcherTimer(::Windows::UI::Xaml::DispatcherTimer^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::DispatcherTimer^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DispatcherTimer^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::DispatcherTimer^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::DispatcherTimer();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      DispatcherTimer *wrapperInstance = new DispatcherTimer(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DispatcherTimer^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::DispatcherTimer^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::DispatcherTimer^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapDispatcherTimer(winRtInstance));
    }


    static void Start(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DispatcherTimer^>(info.This())) {
        return;
      }

      DispatcherTimer *wrapper = DispatcherTimer::Unwrap<DispatcherTimer>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->Start();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Stop(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DispatcherTimer^>(info.This())) {
        return;
      }

      DispatcherTimer *wrapper = DispatcherTimer::Unwrap<DispatcherTimer>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->Stop();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    static void IntervalGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DispatcherTimer^>(info.This())) {
        return;
      }

      DispatcherTimer *wrapper = DispatcherTimer::Unwrap<DispatcherTimer>(info.This());

      try  {
        ::Windows::Foundation::TimeSpan result = wrapper->_instance->Interval;
        info.GetReturnValue().Set(Nan::New<Number>(result.Duration/10000.0));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IntervalSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DispatcherTimer^>(info.This())) {
        return;
      }

      DispatcherTimer *wrapper = DispatcherTimer::Unwrap<DispatcherTimer>(info.This());

      try {

        ::Windows::Foundation::TimeSpan winRtValue = NodeRT::Utils::TimeSpanFromMilli(Nan::To<int64_t>(value).FromMaybe(0));

        wrapper->_instance->Interval = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DispatcherTimer^>(info.This())) {
        return;
      }

      DispatcherTimer *wrapper = DispatcherTimer::Unwrap<DispatcherTimer>(info.This());

      try  {
        bool result = wrapper->_instance->IsEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    static void AddListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"tick", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DispatcherTimer^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        DispatcherTimer *wrapper = DispatcherTimer::Unwrap<DispatcherTimer>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->Tick::add(
            ref new ::Windows::Foundation::EventHandler<::Platform::Object^>(
            [callbackObjPtr](::Platform::Object^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
 else  {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Value> tokenMapVal = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());
      Local<Object> tokenMap;

      if (tokenMapVal.IsEmpty() || Nan::Equals(tokenMapVal, Undefined()).FromMaybe(false)) {
        tokenMap = Nan::New<Object>();
        NodeRT::Utils::SetHiddenValueWithObject(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked(), tokenMap);
      } else {
        tokenMap = Nan::To<Object>(tokenMapVal).ToLocalChecked();
      }

      Nan::Set(tokenMap, info[0], CreateOpaqueWrapper(::Windows::Foundation::PropertyValue::CreateInt64(registrationToken.Value)));
    }

    static void RemoveListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected a string and a callback")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      if ((!NodeRT::Utils::CaseInsenstiveEquals(L"tick", str))) {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Function> callback = info[1].As<Function>();
      Local<Value> tokenMap = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());

      if (tokenMap.IsEmpty() || Nan::Equals(tokenMap, Undefined()).FromMaybe(false)) {
        return;
      }

      Local<Value> opaqueWrapperObj =  Nan::Get(Nan::To<Object>(tokenMap).ToLocalChecked(), info[0]).ToLocalChecked();

      if (opaqueWrapperObj.IsEmpty() || Nan::Equals(opaqueWrapperObj,Undefined()).FromMaybe(false)) {
        return;
      }

      OpaqueWrapper *opaqueWrapper = OpaqueWrapper::Unwrap<OpaqueWrapper>(opaqueWrapperObj.As<Object>());

      long long tokenValue = (long long) opaqueWrapper->GetObjectInstance();
      ::Windows::Foundation::EventRegistrationToken registrationToken;
      registrationToken.Value = tokenValue;

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"tick", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DispatcherTimer^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          DispatcherTimer *wrapper = DispatcherTimer::Unwrap<DispatcherTimer>(info.This());
          wrapper->_instance->Tick::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

      Nan::Delete(Nan::To<Object>(tokenMap).ToLocalChecked(), Nan::To<String>(info[0]).ToLocalChecked());
    }
    private:
      ::Windows::UI::Xaml::DispatcherTimer^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapDispatcherTimer(::Windows::UI::Xaml::DispatcherTimer^ wintRtInstance);
      friend ::Windows::UI::Xaml::DispatcherTimer^ UnwrapDispatcherTimer(Local<Value> value);
  };

  Persistent<FunctionTemplate> DispatcherTimer::s_constructorTemplate;

  v8::Local<v8::Value> WrapDispatcherTimer(::Windows::UI::Xaml::DispatcherTimer^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(DispatcherTimer::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::DispatcherTimer^ UnwrapDispatcherTimer(Local<Value> value) {
     return DispatcherTimer::Unwrap<DispatcherTimer>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitDispatcherTimer(Local<Object> exports) {
    DispatcherTimer::Init(exports);
  }

  class DragEventArgs : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("DragEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "getPosition", GetPosition);
            Nan::SetPrototypeMethod(localRef, "getDeferral", GetDeferral);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("handled").ToLocalChecked(), HandledGetter, HandledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("data").ToLocalChecked(), DataGetter, DataSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("acceptedOperation").ToLocalChecked(), AcceptedOperationGetter, AcceptedOperationSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dataView").ToLocalChecked(), DataViewGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dragUIOverride").ToLocalChecked(), DragUIOverrideGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("modifiers").ToLocalChecked(), ModifiersGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("allowedOperations").ToLocalChecked(), AllowedOperationsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("originalSource").ToLocalChecked(), OriginalSourceGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("DragEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      DragEventArgs(::Windows::UI::Xaml::DragEventArgs^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::DragEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::DragEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      DragEventArgs *wrapperInstance = new DragEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::DragEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::DragEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapDragEventArgs(winRtInstance));
    }


    static void GetPosition(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragEventArgs^>(info.This())) {
        return;
      }

      DragEventArgs *wrapper = DragEventArgs::Unwrap<DragEventArgs>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::UIElement^ arg0 = UnwrapUIElement(info[0]);
          
          ::Windows::Foundation::Point result;
          result = wrapper->_instance->GetPosition(arg0);
          info.GetReturnValue().Set(NodeRT::Utils::PointToJs(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetDeferral(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragEventArgs^>(info.This())) {
        return;
      }

      DragEventArgs *wrapper = DragEventArgs::Unwrap<DragEventArgs>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::UI::Xaml::DragOperationDeferral^ result;
          result = wrapper->_instance->GetDeferral();
          info.GetReturnValue().Set(WrapDragOperationDeferral(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    static void HandledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragEventArgs^>(info.This())) {
        return;
      }

      DragEventArgs *wrapper = DragEventArgs::Unwrap<DragEventArgs>(info.This());

      try  {
        bool result = wrapper->_instance->Handled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void HandledSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragEventArgs^>(info.This())) {
        return;
      }

      DragEventArgs *wrapper = DragEventArgs::Unwrap<DragEventArgs>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->Handled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void DataGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragEventArgs^>(info.This())) {
        return;
      }

      DragEventArgs *wrapper = DragEventArgs::Unwrap<DragEventArgs>(info.This());

      try  {
        ::Windows::ApplicationModel::DataTransfer::DataPackage^ result = wrapper->_instance->Data;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel.DataTransfer", "DataPackage", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DataSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::DataTransfer::DataPackage^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragEventArgs^>(info.This())) {
        return;
      }

      DragEventArgs *wrapper = DragEventArgs::Unwrap<DragEventArgs>(info.This());

      try {

        ::Windows::ApplicationModel::DataTransfer::DataPackage^ winRtValue = dynamic_cast<::Windows::ApplicationModel::DataTransfer::DataPackage^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Data = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void AcceptedOperationGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragEventArgs^>(info.This())) {
        return;
      }

      DragEventArgs *wrapper = DragEventArgs::Unwrap<DragEventArgs>(info.This());

      try  {
        ::Windows::ApplicationModel::DataTransfer::DataPackageOperation result = wrapper->_instance->AcceptedOperation;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AcceptedOperationSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragEventArgs^>(info.This())) {
        return;
      }

      DragEventArgs *wrapper = DragEventArgs::Unwrap<DragEventArgs>(info.This());

      try {

        ::Windows::ApplicationModel::DataTransfer::DataPackageOperation winRtValue = static_cast<::Windows::ApplicationModel::DataTransfer::DataPackageOperation>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->AcceptedOperation = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void DataViewGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragEventArgs^>(info.This())) {
        return;
      }

      DragEventArgs *wrapper = DragEventArgs::Unwrap<DragEventArgs>(info.This());

      try  {
        ::Windows::ApplicationModel::DataTransfer::DataPackageView^ result = wrapper->_instance->DataView;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel.DataTransfer", "DataPackageView", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DragUIOverrideGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragEventArgs^>(info.This())) {
        return;
      }

      DragEventArgs *wrapper = DragEventArgs::Unwrap<DragEventArgs>(info.This());

      try  {
        ::Windows::UI::Xaml::DragUIOverride^ result = wrapper->_instance->DragUIOverride;
        info.GetReturnValue().Set(WrapDragUIOverride(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ModifiersGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragEventArgs^>(info.This())) {
        return;
      }

      DragEventArgs *wrapper = DragEventArgs::Unwrap<DragEventArgs>(info.This());

      try  {
        ::Windows::ApplicationModel::DataTransfer::DragDrop::DragDropModifiers result = wrapper->_instance->Modifiers;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AllowedOperationsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragEventArgs^>(info.This())) {
        return;
      }

      DragEventArgs *wrapper = DragEventArgs::Unwrap<DragEventArgs>(info.This());

      try  {
        ::Windows::ApplicationModel::DataTransfer::DataPackageOperation result = wrapper->_instance->AllowedOperations;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void OriginalSourceGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::RoutedEventArgs^>(info.This())) {
        return;
      }

      RoutedEventArgs *wrapper = RoutedEventArgs::Unwrap<RoutedEventArgs>(info.This());

      try  {
        ::Platform::Object^ result = wrapper->_instance->OriginalSource;
        info.GetReturnValue().Set(CreateOpaqueWrapper(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::DragEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapDragEventArgs(::Windows::UI::Xaml::DragEventArgs^ wintRtInstance);
      friend ::Windows::UI::Xaml::DragEventArgs^ UnwrapDragEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> DragEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapDragEventArgs(::Windows::UI::Xaml::DragEventArgs^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(DragEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::DragEventArgs^ UnwrapDragEventArgs(Local<Value> value) {
     return DragEventArgs::Unwrap<DragEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitDragEventArgs(Local<Object> exports) {
    DragEventArgs::Init(exports);
  }

  class DragOperationDeferral : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("DragOperationDeferral").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "complete", Complete);
          




        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("DragOperationDeferral").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      DragOperationDeferral(::Windows::UI::Xaml::DragOperationDeferral^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::DragOperationDeferral^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragOperationDeferral^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::DragOperationDeferral^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      DragOperationDeferral *wrapperInstance = new DragOperationDeferral(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragOperationDeferral^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::DragOperationDeferral^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::DragOperationDeferral^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapDragOperationDeferral(winRtInstance));
    }


    static void Complete(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragOperationDeferral^>(info.This())) {
        return;
      }

      DragOperationDeferral *wrapper = DragOperationDeferral::Unwrap<DragOperationDeferral>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->Complete();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





    private:
      ::Windows::UI::Xaml::DragOperationDeferral^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapDragOperationDeferral(::Windows::UI::Xaml::DragOperationDeferral^ wintRtInstance);
      friend ::Windows::UI::Xaml::DragOperationDeferral^ UnwrapDragOperationDeferral(Local<Value> value);
  };

  Persistent<FunctionTemplate> DragOperationDeferral::s_constructorTemplate;

  v8::Local<v8::Value> WrapDragOperationDeferral(::Windows::UI::Xaml::DragOperationDeferral^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(DragOperationDeferral::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::DragOperationDeferral^ UnwrapDragOperationDeferral(Local<Value> value) {
     return DragOperationDeferral::Unwrap<DragOperationDeferral>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitDragOperationDeferral(Local<Object> exports) {
    DragOperationDeferral::Init(exports);
  }

  class DragStartingEventArgs : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("DragStartingEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "getDeferral", GetDeferral);
            Nan::SetPrototypeMethod(localRef, "getPosition", GetPosition);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("cancel").ToLocalChecked(), CancelGetter, CancelSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("data").ToLocalChecked(), DataGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dragUI").ToLocalChecked(), DragUIGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("allowedOperations").ToLocalChecked(), AllowedOperationsGetter, AllowedOperationsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("originalSource").ToLocalChecked(), OriginalSourceGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("DragStartingEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      DragStartingEventArgs(::Windows::UI::Xaml::DragStartingEventArgs^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::DragStartingEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragStartingEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::DragStartingEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      DragStartingEventArgs *wrapperInstance = new DragStartingEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragStartingEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::DragStartingEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::DragStartingEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapDragStartingEventArgs(winRtInstance));
    }


    static void GetDeferral(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragStartingEventArgs^>(info.This())) {
        return;
      }

      DragStartingEventArgs *wrapper = DragStartingEventArgs::Unwrap<DragStartingEventArgs>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::UI::Xaml::DragOperationDeferral^ result;
          result = wrapper->_instance->GetDeferral();
          info.GetReturnValue().Set(WrapDragOperationDeferral(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetPosition(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragStartingEventArgs^>(info.This())) {
        return;
      }

      DragStartingEventArgs *wrapper = DragStartingEventArgs::Unwrap<DragStartingEventArgs>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::UIElement^ arg0 = UnwrapUIElement(info[0]);
          
          ::Windows::Foundation::Point result;
          result = wrapper->_instance->GetPosition(arg0);
          info.GetReturnValue().Set(NodeRT::Utils::PointToJs(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    static void CancelGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragStartingEventArgs^>(info.This())) {
        return;
      }

      DragStartingEventArgs *wrapper = DragStartingEventArgs::Unwrap<DragStartingEventArgs>(info.This());

      try  {
        bool result = wrapper->_instance->Cancel;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CancelSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragStartingEventArgs^>(info.This())) {
        return;
      }

      DragStartingEventArgs *wrapper = DragStartingEventArgs::Unwrap<DragStartingEventArgs>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->Cancel = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void DataGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragStartingEventArgs^>(info.This())) {
        return;
      }

      DragStartingEventArgs *wrapper = DragStartingEventArgs::Unwrap<DragStartingEventArgs>(info.This());

      try  {
        ::Windows::ApplicationModel::DataTransfer::DataPackage^ result = wrapper->_instance->Data;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel.DataTransfer", "DataPackage", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DragUIGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragStartingEventArgs^>(info.This())) {
        return;
      }

      DragStartingEventArgs *wrapper = DragStartingEventArgs::Unwrap<DragStartingEventArgs>(info.This());

      try  {
        ::Windows::UI::Xaml::DragUI^ result = wrapper->_instance->DragUI;
        info.GetReturnValue().Set(WrapDragUI(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AllowedOperationsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragStartingEventArgs^>(info.This())) {
        return;
      }

      DragStartingEventArgs *wrapper = DragStartingEventArgs::Unwrap<DragStartingEventArgs>(info.This());

      try  {
        ::Windows::ApplicationModel::DataTransfer::DataPackageOperation result = wrapper->_instance->AllowedOperations;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AllowedOperationsSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragStartingEventArgs^>(info.This())) {
        return;
      }

      DragStartingEventArgs *wrapper = DragStartingEventArgs::Unwrap<DragStartingEventArgs>(info.This());

      try {

        ::Windows::ApplicationModel::DataTransfer::DataPackageOperation winRtValue = static_cast<::Windows::ApplicationModel::DataTransfer::DataPackageOperation>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->AllowedOperations = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void OriginalSourceGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::RoutedEventArgs^>(info.This())) {
        return;
      }

      RoutedEventArgs *wrapper = RoutedEventArgs::Unwrap<RoutedEventArgs>(info.This());

      try  {
        ::Platform::Object^ result = wrapper->_instance->OriginalSource;
        info.GetReturnValue().Set(CreateOpaqueWrapper(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::DragStartingEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapDragStartingEventArgs(::Windows::UI::Xaml::DragStartingEventArgs^ wintRtInstance);
      friend ::Windows::UI::Xaml::DragStartingEventArgs^ UnwrapDragStartingEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> DragStartingEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapDragStartingEventArgs(::Windows::UI::Xaml::DragStartingEventArgs^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(DragStartingEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::DragStartingEventArgs^ UnwrapDragStartingEventArgs(Local<Value> value) {
     return DragStartingEventArgs::Unwrap<DragStartingEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitDragStartingEventArgs(Local<Object> exports) {
    DragStartingEventArgs::Init(exports);
  }

  class DragUI : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("DragUI").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "setContentFromBitmapImage", SetContentFromBitmapImage);
            Nan::SetPrototypeMethod(localRef, "setContentFromSoftwareBitmap", SetContentFromSoftwareBitmap);
            Nan::SetPrototypeMethod(localRef, "setContentFromDataPackage", SetContentFromDataPackage);
          




        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("DragUI").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      DragUI(::Windows::UI::Xaml::DragUI^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::DragUI^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragUI^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::DragUI^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      DragUI *wrapperInstance = new DragUI(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragUI^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::DragUI^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::DragUI^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapDragUI(winRtInstance));
    }


    static void SetContentFromBitmapImage(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragUI^>(info.This())) {
        return;
      }

      DragUI *wrapper = DragUI::Unwrap<DragUI>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Media::Imaging::BitmapImage^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::Media::Imaging::BitmapImage^ arg0 = dynamic_cast<::Windows::UI::Xaml::Media::Imaging::BitmapImage^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          wrapper->_instance->SetContentFromBitmapImage(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Media::Imaging::BitmapImage^>(info[0])
        && NodeRT::Utils::IsPoint(info[1]))
      {
        try
        {
          ::Windows::UI::Xaml::Media::Imaging::BitmapImage^ arg0 = dynamic_cast<::Windows::UI::Xaml::Media::Imaging::BitmapImage^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Foundation::Point arg1 = NodeRT::Utils::PointFromJs(info[1]);
          
          wrapper->_instance->SetContentFromBitmapImage(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void SetContentFromSoftwareBitmap(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragUI^>(info.This())) {
        return;
      }

      DragUI *wrapper = DragUI::Unwrap<DragUI>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Imaging::SoftwareBitmap^>(info[0]))
      {
        try
        {
          ::Windows::Graphics::Imaging::SoftwareBitmap^ arg0 = dynamic_cast<::Windows::Graphics::Imaging::SoftwareBitmap^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          wrapper->_instance->SetContentFromSoftwareBitmap(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Imaging::SoftwareBitmap^>(info[0])
        && NodeRT::Utils::IsPoint(info[1]))
      {
        try
        {
          ::Windows::Graphics::Imaging::SoftwareBitmap^ arg0 = dynamic_cast<::Windows::Graphics::Imaging::SoftwareBitmap^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Foundation::Point arg1 = NodeRT::Utils::PointFromJs(info[1]);
          
          wrapper->_instance->SetContentFromSoftwareBitmap(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void SetContentFromDataPackage(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragUI^>(info.This())) {
        return;
      }

      DragUI *wrapper = DragUI::Unwrap<DragUI>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->SetContentFromDataPackage();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





    private:
      ::Windows::UI::Xaml::DragUI^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapDragUI(::Windows::UI::Xaml::DragUI^ wintRtInstance);
      friend ::Windows::UI::Xaml::DragUI^ UnwrapDragUI(Local<Value> value);
  };

  Persistent<FunctionTemplate> DragUI::s_constructorTemplate;

  v8::Local<v8::Value> WrapDragUI(::Windows::UI::Xaml::DragUI^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(DragUI::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::DragUI^ UnwrapDragUI(Local<Value> value) {
     return DragUI::Unwrap<DragUI>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitDragUI(Local<Object> exports) {
    DragUI::Init(exports);
  }

  class DragUIOverride : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("DragUIOverride").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "clear", Clear);
            Nan::SetPrototypeMethod(localRef, "setContentFromBitmapImage", SetContentFromBitmapImage);
            Nan::SetPrototypeMethod(localRef, "setContentFromSoftwareBitmap", SetContentFromSoftwareBitmap);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isGlyphVisible").ToLocalChecked(), IsGlyphVisibleGetter, IsGlyphVisibleSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isContentVisible").ToLocalChecked(), IsContentVisibleGetter, IsContentVisibleSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isCaptionVisible").ToLocalChecked(), IsCaptionVisibleGetter, IsCaptionVisibleSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("caption").ToLocalChecked(), CaptionGetter, CaptionSetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("DragUIOverride").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      DragUIOverride(::Windows::UI::Xaml::DragUIOverride^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::DragUIOverride^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragUIOverride^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::DragUIOverride^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      DragUIOverride *wrapperInstance = new DragUIOverride(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragUIOverride^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::DragUIOverride^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::DragUIOverride^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapDragUIOverride(winRtInstance));
    }


    static void Clear(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragUIOverride^>(info.This())) {
        return;
      }

      DragUIOverride *wrapper = DragUIOverride::Unwrap<DragUIOverride>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->Clear();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void SetContentFromBitmapImage(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragUIOverride^>(info.This())) {
        return;
      }

      DragUIOverride *wrapper = DragUIOverride::Unwrap<DragUIOverride>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Media::Imaging::BitmapImage^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::Media::Imaging::BitmapImage^ arg0 = dynamic_cast<::Windows::UI::Xaml::Media::Imaging::BitmapImage^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          wrapper->_instance->SetContentFromBitmapImage(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Media::Imaging::BitmapImage^>(info[0])
        && NodeRT::Utils::IsPoint(info[1]))
      {
        try
        {
          ::Windows::UI::Xaml::Media::Imaging::BitmapImage^ arg0 = dynamic_cast<::Windows::UI::Xaml::Media::Imaging::BitmapImage^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Foundation::Point arg1 = NodeRT::Utils::PointFromJs(info[1]);
          
          wrapper->_instance->SetContentFromBitmapImage(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void SetContentFromSoftwareBitmap(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragUIOverride^>(info.This())) {
        return;
      }

      DragUIOverride *wrapper = DragUIOverride::Unwrap<DragUIOverride>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Imaging::SoftwareBitmap^>(info[0]))
      {
        try
        {
          ::Windows::Graphics::Imaging::SoftwareBitmap^ arg0 = dynamic_cast<::Windows::Graphics::Imaging::SoftwareBitmap^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          wrapper->_instance->SetContentFromSoftwareBitmap(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Imaging::SoftwareBitmap^>(info[0])
        && NodeRT::Utils::IsPoint(info[1]))
      {
        try
        {
          ::Windows::Graphics::Imaging::SoftwareBitmap^ arg0 = dynamic_cast<::Windows::Graphics::Imaging::SoftwareBitmap^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Foundation::Point arg1 = NodeRT::Utils::PointFromJs(info[1]);
          
          wrapper->_instance->SetContentFromSoftwareBitmap(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    static void IsGlyphVisibleGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragUIOverride^>(info.This())) {
        return;
      }

      DragUIOverride *wrapper = DragUIOverride::Unwrap<DragUIOverride>(info.This());

      try  {
        bool result = wrapper->_instance->IsGlyphVisible;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsGlyphVisibleSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragUIOverride^>(info.This())) {
        return;
      }

      DragUIOverride *wrapper = DragUIOverride::Unwrap<DragUIOverride>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsGlyphVisible = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsContentVisibleGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragUIOverride^>(info.This())) {
        return;
      }

      DragUIOverride *wrapper = DragUIOverride::Unwrap<DragUIOverride>(info.This());

      try  {
        bool result = wrapper->_instance->IsContentVisible;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsContentVisibleSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragUIOverride^>(info.This())) {
        return;
      }

      DragUIOverride *wrapper = DragUIOverride::Unwrap<DragUIOverride>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsContentVisible = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsCaptionVisibleGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragUIOverride^>(info.This())) {
        return;
      }

      DragUIOverride *wrapper = DragUIOverride::Unwrap<DragUIOverride>(info.This());

      try  {
        bool result = wrapper->_instance->IsCaptionVisible;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsCaptionVisibleSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragUIOverride^>(info.This())) {
        return;
      }

      DragUIOverride *wrapper = DragUIOverride::Unwrap<DragUIOverride>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsCaptionVisible = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void CaptionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragUIOverride^>(info.This())) {
        return;
      }

      DragUIOverride *wrapper = DragUIOverride::Unwrap<DragUIOverride>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Caption;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CaptionSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsString()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DragUIOverride^>(info.This())) {
        return;
      }

      DragUIOverride *wrapper = DragUIOverride::Unwrap<DragUIOverride>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->Caption = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      


    private:
      ::Windows::UI::Xaml::DragUIOverride^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapDragUIOverride(::Windows::UI::Xaml::DragUIOverride^ wintRtInstance);
      friend ::Windows::UI::Xaml::DragUIOverride^ UnwrapDragUIOverride(Local<Value> value);
  };

  Persistent<FunctionTemplate> DragUIOverride::s_constructorTemplate;

  v8::Local<v8::Value> WrapDragUIOverride(::Windows::UI::Xaml::DragUIOverride^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(DragUIOverride::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::DragUIOverride^ UnwrapDragUIOverride(Local<Value> value) {
     return DragUIOverride::Unwrap<DragUIOverride>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitDragUIOverride(Local<Object> exports) {
    DragUIOverride::Init(exports);
  }

  class DropCompletedEventArgs : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("DropCompletedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dropResult").ToLocalChecked(), DropResultGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("originalSource").ToLocalChecked(), OriginalSourceGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("DropCompletedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      DropCompletedEventArgs(::Windows::UI::Xaml::DropCompletedEventArgs^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::DropCompletedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DropCompletedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::DropCompletedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      DropCompletedEventArgs *wrapperInstance = new DropCompletedEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DropCompletedEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::DropCompletedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::DropCompletedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapDropCompletedEventArgs(winRtInstance));
    }





    static void DropResultGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DropCompletedEventArgs^>(info.This())) {
        return;
      }

      DropCompletedEventArgs *wrapper = DropCompletedEventArgs::Unwrap<DropCompletedEventArgs>(info.This());

      try  {
        ::Windows::ApplicationModel::DataTransfer::DataPackageOperation result = wrapper->_instance->DropResult;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void OriginalSourceGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::RoutedEventArgs^>(info.This())) {
        return;
      }

      RoutedEventArgs *wrapper = RoutedEventArgs::Unwrap<RoutedEventArgs>(info.This());

      try  {
        ::Platform::Object^ result = wrapper->_instance->OriginalSource;
        info.GetReturnValue().Set(CreateOpaqueWrapper(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::DropCompletedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapDropCompletedEventArgs(::Windows::UI::Xaml::DropCompletedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Xaml::DropCompletedEventArgs^ UnwrapDropCompletedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> DropCompletedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapDropCompletedEventArgs(::Windows::UI::Xaml::DropCompletedEventArgs^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(DropCompletedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::DropCompletedEventArgs^ UnwrapDropCompletedEventArgs(Local<Value> value) {
     return DropCompletedEventArgs::Unwrap<DropCompletedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitDropCompletedEventArgs(Local<Object> exports) {
    DropCompletedEventArgs::Init(exports);
  }

  class EffectiveViewportChangedEventArgs : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("EffectiveViewportChangedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("bringIntoViewDistanceX").ToLocalChecked(), BringIntoViewDistanceXGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("bringIntoViewDistanceY").ToLocalChecked(), BringIntoViewDistanceYGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("effectiveViewport").ToLocalChecked(), EffectiveViewportGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxViewport").ToLocalChecked(), MaxViewportGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("EffectiveViewportChangedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      EffectiveViewportChangedEventArgs(::Windows::UI::Xaml::EffectiveViewportChangedEventArgs^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::EffectiveViewportChangedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::EffectiveViewportChangedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::EffectiveViewportChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      EffectiveViewportChangedEventArgs *wrapperInstance = new EffectiveViewportChangedEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::EffectiveViewportChangedEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::EffectiveViewportChangedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::EffectiveViewportChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapEffectiveViewportChangedEventArgs(winRtInstance));
    }





    static void BringIntoViewDistanceXGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::EffectiveViewportChangedEventArgs^>(info.This())) {
        return;
      }

      EffectiveViewportChangedEventArgs *wrapper = EffectiveViewportChangedEventArgs::Unwrap<EffectiveViewportChangedEventArgs>(info.This());

      try  {
        double result = wrapper->_instance->BringIntoViewDistanceX;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BringIntoViewDistanceYGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::EffectiveViewportChangedEventArgs^>(info.This())) {
        return;
      }

      EffectiveViewportChangedEventArgs *wrapper = EffectiveViewportChangedEventArgs::Unwrap<EffectiveViewportChangedEventArgs>(info.This());

      try  {
        double result = wrapper->_instance->BringIntoViewDistanceY;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void EffectiveViewportGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::EffectiveViewportChangedEventArgs^>(info.This())) {
        return;
      }

      EffectiveViewportChangedEventArgs *wrapper = EffectiveViewportChangedEventArgs::Unwrap<EffectiveViewportChangedEventArgs>(info.This());

      try  {
        ::Windows::Foundation::Rect result = wrapper->_instance->EffectiveViewport;
        info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MaxViewportGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::EffectiveViewportChangedEventArgs^>(info.This())) {
        return;
      }

      EffectiveViewportChangedEventArgs *wrapper = EffectiveViewportChangedEventArgs::Unwrap<EffectiveViewportChangedEventArgs>(info.This());

      try  {
        ::Windows::Foundation::Rect result = wrapper->_instance->MaxViewport;
        info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::EffectiveViewportChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapEffectiveViewportChangedEventArgs(::Windows::UI::Xaml::EffectiveViewportChangedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Xaml::EffectiveViewportChangedEventArgs^ UnwrapEffectiveViewportChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> EffectiveViewportChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapEffectiveViewportChangedEventArgs(::Windows::UI::Xaml::EffectiveViewportChangedEventArgs^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(EffectiveViewportChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::EffectiveViewportChangedEventArgs^ UnwrapEffectiveViewportChangedEventArgs(Local<Value> value) {
     return EffectiveViewportChangedEventArgs::Unwrap<EffectiveViewportChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitEffectiveViewportChangedEventArgs(Local<Object> exports) {
    EffectiveViewportChangedEventArgs::Init(exports);
  }

  class ElementFactoryGetArgs : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("ElementFactoryGetArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("parent").ToLocalChecked(), ParentGetter, ParentSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("data").ToLocalChecked(), DataGetter, DataSetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ElementFactoryGetArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ElementFactoryGetArgs(::Windows::UI::Xaml::ElementFactoryGetArgs^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::ElementFactoryGetArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ElementFactoryGetArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::ElementFactoryGetArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::ElementFactoryGetArgs();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      ElementFactoryGetArgs *wrapperInstance = new ElementFactoryGetArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ElementFactoryGetArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::ElementFactoryGetArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::ElementFactoryGetArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapElementFactoryGetArgs(winRtInstance));
    }





    static void ParentGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ElementFactoryGetArgs^>(info.This())) {
        return;
      }

      ElementFactoryGetArgs *wrapper = ElementFactoryGetArgs::Unwrap<ElementFactoryGetArgs>(info.This());

      try  {
        ::Windows::UI::Xaml::UIElement^ result = wrapper->_instance->Parent;
        info.GetReturnValue().Set(WrapUIElement(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ParentSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ElementFactoryGetArgs^>(info.This())) {
        return;
      }

      ElementFactoryGetArgs *wrapper = ElementFactoryGetArgs::Unwrap<ElementFactoryGetArgs>(info.This());

      try {

        ::Windows::UI::Xaml::UIElement^ winRtValue = dynamic_cast<::Windows::UI::Xaml::UIElement^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Parent = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void DataGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ElementFactoryGetArgs^>(info.This())) {
        return;
      }

      ElementFactoryGetArgs *wrapper = ElementFactoryGetArgs::Unwrap<ElementFactoryGetArgs>(info.This());

      try  {
        ::Platform::Object^ result = wrapper->_instance->Data;
        info.GetReturnValue().Set(CreateOpaqueWrapper(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DataSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ElementFactoryGetArgs^>(info.This())) {
        return;
      }

      ElementFactoryGetArgs *wrapper = ElementFactoryGetArgs::Unwrap<ElementFactoryGetArgs>(info.This());

      try {

        ::Platform::Object^ winRtValue = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Data = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      


    private:
      ::Windows::UI::Xaml::ElementFactoryGetArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapElementFactoryGetArgs(::Windows::UI::Xaml::ElementFactoryGetArgs^ wintRtInstance);
      friend ::Windows::UI::Xaml::ElementFactoryGetArgs^ UnwrapElementFactoryGetArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> ElementFactoryGetArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapElementFactoryGetArgs(::Windows::UI::Xaml::ElementFactoryGetArgs^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(ElementFactoryGetArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::ElementFactoryGetArgs^ UnwrapElementFactoryGetArgs(Local<Value> value) {
     return ElementFactoryGetArgs::Unwrap<ElementFactoryGetArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitElementFactoryGetArgs(Local<Object> exports) {
    ElementFactoryGetArgs::Init(exports);
  }

  class ElementFactoryRecycleArgs : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("ElementFactoryRecycleArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("parent").ToLocalChecked(), ParentGetter, ParentSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("element").ToLocalChecked(), ElementGetter, ElementSetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ElementFactoryRecycleArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ElementFactoryRecycleArgs(::Windows::UI::Xaml::ElementFactoryRecycleArgs^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::ElementFactoryRecycleArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ElementFactoryRecycleArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::ElementFactoryRecycleArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::ElementFactoryRecycleArgs();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      ElementFactoryRecycleArgs *wrapperInstance = new ElementFactoryRecycleArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ElementFactoryRecycleArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::ElementFactoryRecycleArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::ElementFactoryRecycleArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapElementFactoryRecycleArgs(winRtInstance));
    }





    static void ParentGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ElementFactoryRecycleArgs^>(info.This())) {
        return;
      }

      ElementFactoryRecycleArgs *wrapper = ElementFactoryRecycleArgs::Unwrap<ElementFactoryRecycleArgs>(info.This());

      try  {
        ::Windows::UI::Xaml::UIElement^ result = wrapper->_instance->Parent;
        info.GetReturnValue().Set(WrapUIElement(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ParentSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ElementFactoryRecycleArgs^>(info.This())) {
        return;
      }

      ElementFactoryRecycleArgs *wrapper = ElementFactoryRecycleArgs::Unwrap<ElementFactoryRecycleArgs>(info.This());

      try {

        ::Windows::UI::Xaml::UIElement^ winRtValue = dynamic_cast<::Windows::UI::Xaml::UIElement^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Parent = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ElementGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ElementFactoryRecycleArgs^>(info.This())) {
        return;
      }

      ElementFactoryRecycleArgs *wrapper = ElementFactoryRecycleArgs::Unwrap<ElementFactoryRecycleArgs>(info.This());

      try  {
        ::Windows::UI::Xaml::UIElement^ result = wrapper->_instance->Element;
        info.GetReturnValue().Set(WrapUIElement(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ElementSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ElementFactoryRecycleArgs^>(info.This())) {
        return;
      }

      ElementFactoryRecycleArgs *wrapper = ElementFactoryRecycleArgs::Unwrap<ElementFactoryRecycleArgs>(info.This());

      try {

        ::Windows::UI::Xaml::UIElement^ winRtValue = dynamic_cast<::Windows::UI::Xaml::UIElement^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Element = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      


    private:
      ::Windows::UI::Xaml::ElementFactoryRecycleArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapElementFactoryRecycleArgs(::Windows::UI::Xaml::ElementFactoryRecycleArgs^ wintRtInstance);
      friend ::Windows::UI::Xaml::ElementFactoryRecycleArgs^ UnwrapElementFactoryRecycleArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> ElementFactoryRecycleArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapElementFactoryRecycleArgs(::Windows::UI::Xaml::ElementFactoryRecycleArgs^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(ElementFactoryRecycleArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::ElementFactoryRecycleArgs^ UnwrapElementFactoryRecycleArgs(Local<Value> value) {
     return ElementFactoryRecycleArgs::Unwrap<ElementFactoryRecycleArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitElementFactoryRecycleArgs(Local<Object> exports) {
    ElementFactoryRecycleArgs::Init(exports);
  }

  class ElementSoundPlayer : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("ElementSoundPlayer").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);






        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetMethod(constructor, "play", Play);
        Nan::SetAccessor(constructor, Nan::New<String>("volume").ToLocalChecked(), VolumeGetter, VolumeSetter);
        Nan::SetAccessor(constructor, Nan::New<String>("state").ToLocalChecked(), StateGetter, StateSetter);
        Nan::SetAccessor(constructor, Nan::New<String>("spatialAudioMode").ToLocalChecked(), SpatialAudioModeGetter, SpatialAudioModeSetter);


        Nan::Set(exports, Nan::New<String>("ElementSoundPlayer").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ElementSoundPlayer(::Windows::UI::Xaml::ElementSoundPlayer^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::ElementSoundPlayer^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ElementSoundPlayer^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::ElementSoundPlayer^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      ElementSoundPlayer *wrapperInstance = new ElementSoundPlayer(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ElementSoundPlayer^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::ElementSoundPlayer^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::ElementSoundPlayer^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapElementSoundPlayer(winRtInstance));
    }





    static void Play(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::UI::Xaml::ElementSoundKind arg0 = static_cast<::Windows::UI::Xaml::ElementSoundKind>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          ::Windows::UI::Xaml::ElementSoundPlayer::Play(arg0);
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    static void VolumeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        double result = ::Windows::UI::Xaml::ElementSoundPlayer::Volume;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void VolumeSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      try {


        double winRtValue = Nan::To<double>(value).FromMaybe(0.0);

        ::Windows::UI::Xaml::ElementSoundPlayer::Volume = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      

    static void StateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::ElementSoundPlayerState result = ::Windows::UI::Xaml::ElementSoundPlayer::State;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void StateSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      try {


        ::Windows::UI::Xaml::ElementSoundPlayerState winRtValue = static_cast<::Windows::UI::Xaml::ElementSoundPlayerState>(Nan::To<int32_t>(value).FromMaybe(0));

        ::Windows::UI::Xaml::ElementSoundPlayer::State = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      

    static void SpatialAudioModeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::ElementSpatialAudioMode result = ::Windows::UI::Xaml::ElementSoundPlayer::SpatialAudioMode;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void SpatialAudioModeSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      try {


        ::Windows::UI::Xaml::ElementSpatialAudioMode winRtValue = static_cast<::Windows::UI::Xaml::ElementSpatialAudioMode>(Nan::To<int32_t>(value).FromMaybe(0));

        ::Windows::UI::Xaml::ElementSoundPlayer::SpatialAudioMode = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      

    private:
      ::Windows::UI::Xaml::ElementSoundPlayer^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapElementSoundPlayer(::Windows::UI::Xaml::ElementSoundPlayer^ wintRtInstance);
      friend ::Windows::UI::Xaml::ElementSoundPlayer^ UnwrapElementSoundPlayer(Local<Value> value);
  };

  Persistent<FunctionTemplate> ElementSoundPlayer::s_constructorTemplate;

  v8::Local<v8::Value> WrapElementSoundPlayer(::Windows::UI::Xaml::ElementSoundPlayer^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(ElementSoundPlayer::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::ElementSoundPlayer^ UnwrapElementSoundPlayer(Local<Value> value) {
     return ElementSoundPlayer::Unwrap<ElementSoundPlayer>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitElementSoundPlayer(Local<Object> exports) {
    ElementSoundPlayer::Init(exports);
  }

  class TriggerBase : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("TriggerBase").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("TriggerBase").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      TriggerBase(::Windows::UI::Xaml::TriggerBase^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::TriggerBase^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerBase^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::TriggerBase^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      TriggerBase *wrapperInstance = new TriggerBase(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerBase^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::TriggerBase^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::TriggerBase^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapTriggerBase(winRtInstance));
    }





    static void DispatcherGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      try  {
        ::Windows::UI::Core::CoreDispatcher^ result = wrapper->_instance->Dispatcher;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "CoreDispatcher", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::TriggerBase^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapTriggerBase(::Windows::UI::Xaml::TriggerBase^ wintRtInstance);
      friend ::Windows::UI::Xaml::TriggerBase^ UnwrapTriggerBase(Local<Value> value);
  };

  Persistent<FunctionTemplate> TriggerBase::s_constructorTemplate;

  v8::Local<v8::Value> WrapTriggerBase(::Windows::UI::Xaml::TriggerBase^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(TriggerBase::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::TriggerBase^ UnwrapTriggerBase(Local<Value> value) {
     return TriggerBase::Unwrap<TriggerBase>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitTriggerBase(Local<Object> exports) {
    TriggerBase::Init(exports);
  }

  class EventTrigger : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("EventTrigger").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("routedEvent").ToLocalChecked(), RoutedEventGetter, RoutedEventSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("actions").ToLocalChecked(), ActionsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("EventTrigger").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      EventTrigger(::Windows::UI::Xaml::EventTrigger^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::EventTrigger^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::EventTrigger^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::EventTrigger^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::EventTrigger();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      EventTrigger *wrapperInstance = new EventTrigger(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::EventTrigger^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::EventTrigger^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::EventTrigger^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapEventTrigger(winRtInstance));
    }





    static void RoutedEventGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::EventTrigger^>(info.This())) {
        return;
      }

      EventTrigger *wrapper = EventTrigger::Unwrap<EventTrigger>(info.This());

      try  {
        ::Windows::UI::Xaml::RoutedEvent^ result = wrapper->_instance->RoutedEvent;
        info.GetReturnValue().Set(WrapRoutedEvent(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RoutedEventSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::RoutedEvent^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::EventTrigger^>(info.This())) {
        return;
      }

      EventTrigger *wrapper = EventTrigger::Unwrap<EventTrigger>(info.This());

      try {

        ::Windows::UI::Xaml::RoutedEvent^ winRtValue = dynamic_cast<::Windows::UI::Xaml::RoutedEvent^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->RoutedEvent = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ActionsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::EventTrigger^>(info.This())) {
        return;
      }

      EventTrigger *wrapper = EventTrigger::Unwrap<EventTrigger>(info.This());

      try  {
        ::Windows::UI::Xaml::TriggerActionCollection^ result = wrapper->_instance->Actions;
        info.GetReturnValue().Set(WrapTriggerActionCollection(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DispatcherGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      try  {
        ::Windows::UI::Core::CoreDispatcher^ result = wrapper->_instance->Dispatcher;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "CoreDispatcher", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::EventTrigger^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapEventTrigger(::Windows::UI::Xaml::EventTrigger^ wintRtInstance);
      friend ::Windows::UI::Xaml::EventTrigger^ UnwrapEventTrigger(Local<Value> value);
  };

  Persistent<FunctionTemplate> EventTrigger::s_constructorTemplate;

  v8::Local<v8::Value> WrapEventTrigger(::Windows::UI::Xaml::EventTrigger^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(EventTrigger::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::EventTrigger^ UnwrapEventTrigger(Local<Value> value) {
     return EventTrigger::Unwrap<EventTrigger>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitEventTrigger(Local<Object> exports) {
    EventTrigger::Init(exports);
  }

  class ExceptionRoutedEventArgs : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("ExceptionRoutedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("errorMessage").ToLocalChecked(), ErrorMessageGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("originalSource").ToLocalChecked(), OriginalSourceGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ExceptionRoutedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ExceptionRoutedEventArgs(::Windows::UI::Xaml::ExceptionRoutedEventArgs^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::ExceptionRoutedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ExceptionRoutedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::ExceptionRoutedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      ExceptionRoutedEventArgs *wrapperInstance = new ExceptionRoutedEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ExceptionRoutedEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::ExceptionRoutedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::ExceptionRoutedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapExceptionRoutedEventArgs(winRtInstance));
    }





    static void ErrorMessageGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ExceptionRoutedEventArgs^>(info.This())) {
        return;
      }

      ExceptionRoutedEventArgs *wrapper = ExceptionRoutedEventArgs::Unwrap<ExceptionRoutedEventArgs>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->ErrorMessage;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void OriginalSourceGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::RoutedEventArgs^>(info.This())) {
        return;
      }

      RoutedEventArgs *wrapper = RoutedEventArgs::Unwrap<RoutedEventArgs>(info.This());

      try  {
        ::Platform::Object^ result = wrapper->_instance->OriginalSource;
        info.GetReturnValue().Set(CreateOpaqueWrapper(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::ExceptionRoutedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapExceptionRoutedEventArgs(::Windows::UI::Xaml::ExceptionRoutedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Xaml::ExceptionRoutedEventArgs^ UnwrapExceptionRoutedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> ExceptionRoutedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapExceptionRoutedEventArgs(::Windows::UI::Xaml::ExceptionRoutedEventArgs^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(ExceptionRoutedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::ExceptionRoutedEventArgs^ UnwrapExceptionRoutedEventArgs(Local<Value> value) {
     return ExceptionRoutedEventArgs::Unwrap<ExceptionRoutedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitExceptionRoutedEventArgs(Local<Object> exports) {
    ExceptionRoutedEventArgs::Init(exports);
  }

  class FrameworkView : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("FrameworkView").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "initialize", Initialize);
            Nan::SetPrototypeMethod(localRef, "setWindow", SetWindow);
            Nan::SetPrototypeMethod(localRef, "load", Load);
            Nan::SetPrototypeMethod(localRef, "run", Run);
            Nan::SetPrototypeMethod(localRef, "uninitialize", Uninitialize);
          




        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("FrameworkView").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      FrameworkView(::Windows::UI::Xaml::FrameworkView^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::FrameworkView^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkView^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::FrameworkView^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::FrameworkView();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      FrameworkView *wrapperInstance = new FrameworkView(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkView^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::FrameworkView^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::FrameworkView^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapFrameworkView(winRtInstance));
    }


    static void Initialize(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkView^>(info.This())) {
        return;
      }

      FrameworkView *wrapper = FrameworkView::Unwrap<FrameworkView>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Core::CoreApplicationView^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Core::CoreApplicationView^ arg0 = dynamic_cast<::Windows::ApplicationModel::Core::CoreApplicationView^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          wrapper->_instance->Initialize(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void SetWindow(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkView^>(info.This())) {
        return;
      }

      FrameworkView *wrapper = FrameworkView::Unwrap<FrameworkView>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Core::CoreWindow^>(info[0]))
      {
        try
        {
          ::Windows::UI::Core::CoreWindow^ arg0 = dynamic_cast<::Windows::UI::Core::CoreWindow^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          wrapper->_instance->SetWindow(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Load(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkView^>(info.This())) {
        return;
      }

      FrameworkView *wrapper = FrameworkView::Unwrap<FrameworkView>(info.This());

      if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          wrapper->_instance->Load(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Run(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkView^>(info.This())) {
        return;
      }

      FrameworkView *wrapper = FrameworkView::Unwrap<FrameworkView>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->Run();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Uninitialize(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkView^>(info.This())) {
        return;
      }

      FrameworkView *wrapper = FrameworkView::Unwrap<FrameworkView>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->Uninitialize();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





    private:
      ::Windows::UI::Xaml::FrameworkView^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapFrameworkView(::Windows::UI::Xaml::FrameworkView^ wintRtInstance);
      friend ::Windows::UI::Xaml::FrameworkView^ UnwrapFrameworkView(Local<Value> value);
  };

  Persistent<FunctionTemplate> FrameworkView::s_constructorTemplate;

  v8::Local<v8::Value> WrapFrameworkView(::Windows::UI::Xaml::FrameworkView^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(FrameworkView::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::FrameworkView^ UnwrapFrameworkView(Local<Value> value) {
     return FrameworkView::Unwrap<FrameworkView>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitFrameworkView(Local<Object> exports) {
    FrameworkView::Init(exports);
  }

  class FrameworkViewSource : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("FrameworkViewSource").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "createView", CreateView);
          




        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("FrameworkViewSource").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      FrameworkViewSource(::Windows::UI::Xaml::FrameworkViewSource^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::FrameworkViewSource^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkViewSource^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::FrameworkViewSource^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::FrameworkViewSource();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      FrameworkViewSource *wrapperInstance = new FrameworkViewSource(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkViewSource^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::FrameworkViewSource^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::FrameworkViewSource^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapFrameworkViewSource(winRtInstance));
    }


    static void CreateView(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkViewSource^>(info.This())) {
        return;
      }

      FrameworkViewSource *wrapper = FrameworkViewSource::Unwrap<FrameworkViewSource>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::ApplicationModel::Core::IFrameworkView^ result;
          result = wrapper->_instance->CreateView();
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel.Core", "IFrameworkView", result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





    private:
      ::Windows::UI::Xaml::FrameworkViewSource^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapFrameworkViewSource(::Windows::UI::Xaml::FrameworkViewSource^ wintRtInstance);
      friend ::Windows::UI::Xaml::FrameworkViewSource^ UnwrapFrameworkViewSource(Local<Value> value);
  };

  Persistent<FunctionTemplate> FrameworkViewSource::s_constructorTemplate;

  v8::Local<v8::Value> WrapFrameworkViewSource(::Windows::UI::Xaml::FrameworkViewSource^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(FrameworkViewSource::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::FrameworkViewSource^ UnwrapFrameworkViewSource(Local<Value> value) {
     return FrameworkViewSource::Unwrap<FrameworkViewSource>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitFrameworkViewSource(Local<Object> exports) {
    FrameworkViewSource::Init(exports);
  }

  class IDataTemplateExtension : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("IDataTemplateExtension").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "resetTemplate", ResetTemplate);
            Nan::SetPrototypeMethod(localRef, "processBinding", ProcessBinding);
            Nan::SetPrototypeMethod(localRef, "processBindings", ProcessBindings);
          




        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("IDataTemplateExtension").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      IDataTemplateExtension(::Windows::UI::Xaml::IDataTemplateExtension^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::IDataTemplateExtension^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::IDataTemplateExtension^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::IDataTemplateExtension^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      IDataTemplateExtension *wrapperInstance = new IDataTemplateExtension(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::IDataTemplateExtension^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::IDataTemplateExtension^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::IDataTemplateExtension^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapIDataTemplateExtension(winRtInstance));
    }


    static void ResetTemplate(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::IDataTemplateExtension^>(info.This())) {
        return;
      }

      IDataTemplateExtension *wrapper = IDataTemplateExtension::Unwrap<IDataTemplateExtension>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->ResetTemplate();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void ProcessBinding(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::IDataTemplateExtension^>(info.This())) {
        return;
      }

      IDataTemplateExtension *wrapper = IDataTemplateExtension::Unwrap<IDataTemplateExtension>(info.This());

      if (info.Length() == 1
        && info[0]->IsUint32())
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          
          bool result;
          result = wrapper->_instance->ProcessBinding(arg0);
          info.GetReturnValue().Set(Nan::New<Boolean>(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void ProcessBindings(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::IDataTemplateExtension^>(info.This())) {
        return;
      }

      IDataTemplateExtension *wrapper = IDataTemplateExtension::Unwrap<IDataTemplateExtension>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Controls::ContainerContentChangingEventArgs^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::Controls::ContainerContentChangingEventArgs^ arg0 = dynamic_cast<::Windows::UI::Xaml::Controls::ContainerContentChangingEventArgs^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          int result;
          result = wrapper->_instance->ProcessBindings(arg0);
          info.GetReturnValue().Set(Nan::New<Integer>(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





    private:
      ::Windows::UI::Xaml::IDataTemplateExtension^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIDataTemplateExtension(::Windows::UI::Xaml::IDataTemplateExtension^ wintRtInstance);
      friend ::Windows::UI::Xaml::IDataTemplateExtension^ UnwrapIDataTemplateExtension(Local<Value> value);
  };

  Persistent<FunctionTemplate> IDataTemplateExtension::s_constructorTemplate;

  v8::Local<v8::Value> WrapIDataTemplateExtension(::Windows::UI::Xaml::IDataTemplateExtension^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(IDataTemplateExtension::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::IDataTemplateExtension^ UnwrapIDataTemplateExtension(Local<Value> value) {
     return IDataTemplateExtension::Unwrap<IDataTemplateExtension>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIDataTemplateExtension(Local<Object> exports) {
    IDataTemplateExtension::Init(exports);
  }

  class IElementFactory : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("IElementFactory").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "getElement", GetElement);
            Nan::SetPrototypeMethod(localRef, "recycleElement", RecycleElement);
          




        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("IElementFactory").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      IElementFactory(::Windows::UI::Xaml::IElementFactory^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::IElementFactory^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::IElementFactory^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::IElementFactory^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      IElementFactory *wrapperInstance = new IElementFactory(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::IElementFactory^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::IElementFactory^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::IElementFactory^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapIElementFactory(winRtInstance));
    }


    static void GetElement(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::IElementFactory^>(info.This())) {
        return;
      }

      IElementFactory *wrapper = IElementFactory::Unwrap<IElementFactory>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ElementFactoryGetArgs^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::ElementFactoryGetArgs^ arg0 = UnwrapElementFactoryGetArgs(info[0]);
          
          ::Windows::UI::Xaml::UIElement^ result;
          result = wrapper->_instance->GetElement(arg0);
          info.GetReturnValue().Set(WrapUIElement(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void RecycleElement(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::IElementFactory^>(info.This())) {
        return;
      }

      IElementFactory *wrapper = IElementFactory::Unwrap<IElementFactory>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ElementFactoryRecycleArgs^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::ElementFactoryRecycleArgs^ arg0 = UnwrapElementFactoryRecycleArgs(info[0]);
          
          wrapper->_instance->RecycleElement(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





    private:
      ::Windows::UI::Xaml::IElementFactory^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIElementFactory(::Windows::UI::Xaml::IElementFactory^ wintRtInstance);
      friend ::Windows::UI::Xaml::IElementFactory^ UnwrapIElementFactory(Local<Value> value);
  };

  Persistent<FunctionTemplate> IElementFactory::s_constructorTemplate;

  v8::Local<v8::Value> WrapIElementFactory(::Windows::UI::Xaml::IElementFactory^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(IElementFactory::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::IElementFactory^ UnwrapIElementFactory(Local<Value> value) {
     return IElementFactory::Unwrap<IElementFactory>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIElementFactory(Local<Object> exports) {
    IElementFactory::Init(exports);
  }

  class TriggerAction : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("TriggerAction").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("TriggerAction").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      TriggerAction(::Windows::UI::Xaml::TriggerAction^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::TriggerAction^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerAction^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::TriggerAction^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      TriggerAction *wrapperInstance = new TriggerAction(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerAction^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::TriggerAction^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::TriggerAction^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapTriggerAction(winRtInstance));
    }





    static void DispatcherGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      try  {
        ::Windows::UI::Core::CoreDispatcher^ result = wrapper->_instance->Dispatcher;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "CoreDispatcher", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::TriggerAction^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapTriggerAction(::Windows::UI::Xaml::TriggerAction^ wintRtInstance);
      friend ::Windows::UI::Xaml::TriggerAction^ UnwrapTriggerAction(Local<Value> value);
  };

  Persistent<FunctionTemplate> TriggerAction::s_constructorTemplate;

  v8::Local<v8::Value> WrapTriggerAction(::Windows::UI::Xaml::TriggerAction^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(TriggerAction::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::TriggerAction^ UnwrapTriggerAction(Local<Value> value) {
     return TriggerAction::Unwrap<TriggerAction>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitTriggerAction(Local<Object> exports) {
    TriggerAction::Init(exports);
  }

  class MediaFailedRoutedEventArgs : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("MediaFailedRoutedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("errorTrace").ToLocalChecked(), ErrorTraceGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("errorMessage").ToLocalChecked(), ErrorMessageGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("originalSource").ToLocalChecked(), OriginalSourceGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("MediaFailedRoutedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      MediaFailedRoutedEventArgs(::Windows::UI::Xaml::MediaFailedRoutedEventArgs^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::MediaFailedRoutedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::MediaFailedRoutedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::MediaFailedRoutedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      MediaFailedRoutedEventArgs *wrapperInstance = new MediaFailedRoutedEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::MediaFailedRoutedEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::MediaFailedRoutedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::MediaFailedRoutedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapMediaFailedRoutedEventArgs(winRtInstance));
    }





    static void ErrorTraceGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::MediaFailedRoutedEventArgs^>(info.This())) {
        return;
      }

      MediaFailedRoutedEventArgs *wrapper = MediaFailedRoutedEventArgs::Unwrap<MediaFailedRoutedEventArgs>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->ErrorTrace;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ErrorMessageGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ExceptionRoutedEventArgs^>(info.This())) {
        return;
      }

      ExceptionRoutedEventArgs *wrapper = ExceptionRoutedEventArgs::Unwrap<ExceptionRoutedEventArgs>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->ErrorMessage;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void OriginalSourceGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::RoutedEventArgs^>(info.This())) {
        return;
      }

      RoutedEventArgs *wrapper = RoutedEventArgs::Unwrap<RoutedEventArgs>(info.This());

      try  {
        ::Platform::Object^ result = wrapper->_instance->OriginalSource;
        info.GetReturnValue().Set(CreateOpaqueWrapper(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::MediaFailedRoutedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMediaFailedRoutedEventArgs(::Windows::UI::Xaml::MediaFailedRoutedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Xaml::MediaFailedRoutedEventArgs^ UnwrapMediaFailedRoutedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> MediaFailedRoutedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapMediaFailedRoutedEventArgs(::Windows::UI::Xaml::MediaFailedRoutedEventArgs^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(MediaFailedRoutedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::MediaFailedRoutedEventArgs^ UnwrapMediaFailedRoutedEventArgs(Local<Value> value) {
     return MediaFailedRoutedEventArgs::Unwrap<MediaFailedRoutedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMediaFailedRoutedEventArgs(Local<Object> exports) {
    MediaFailedRoutedEventArgs::Init(exports);
  }

  class PointHelper : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("PointHelper").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);






        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetMethod(constructor, "fromCoordinates", FromCoordinates);


        Nan::Set(exports, Nan::New<String>("PointHelper").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      PointHelper(::Windows::UI::Xaml::PointHelper^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::PointHelper^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::PointHelper^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::PointHelper^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      PointHelper *wrapperInstance = new PointHelper(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::PointHelper^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::PointHelper^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::PointHelper^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapPointHelper(winRtInstance));
    }





    static void FromCoordinates(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && info[0]->IsNumber()
        && info[1]->IsNumber())
      {
        try
        {
          float arg0 = static_cast<float>(Nan::To<double>(info[0]).FromMaybe(0.0));
          float arg1 = static_cast<float>(Nan::To<double>(info[1]).FromMaybe(0.0));
          
          ::Windows::Foundation::Point result;
          result = ::Windows::UI::Xaml::PointHelper::FromCoordinates(arg0, arg1);
          info.GetReturnValue().Set(NodeRT::Utils::PointToJs(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    private:
      ::Windows::UI::Xaml::PointHelper^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPointHelper(::Windows::UI::Xaml::PointHelper^ wintRtInstance);
      friend ::Windows::UI::Xaml::PointHelper^ UnwrapPointHelper(Local<Value> value);
  };

  Persistent<FunctionTemplate> PointHelper::s_constructorTemplate;

  v8::Local<v8::Value> WrapPointHelper(::Windows::UI::Xaml::PointHelper^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(PointHelper::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::PointHelper^ UnwrapPointHelper(Local<Value> value) {
     return PointHelper::Unwrap<PointHelper>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPointHelper(Local<Object> exports) {
    PointHelper::Init(exports);
  }

  class PropertyMetadata : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("PropertyMetadata").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("createDefaultValueCallback").ToLocalChecked(), CreateDefaultValueCallbackGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("defaultValue").ToLocalChecked(), DefaultValueGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetMethod(constructor, "create", Create);


        Nan::Set(exports, Nan::New<String>("PropertyMetadata").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      PropertyMetadata(::Windows::UI::Xaml::PropertyMetadata^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::PropertyMetadata^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::PropertyMetadata^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::PropertyMetadata^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[0]))
      {
        try {
          ::Platform::Object^ arg0 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          winRtInstance = ref new ::Windows::UI::Xaml::PropertyMetadata(arg0);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::PropertyChangedCallback^>(info[1]))
      {
        try {
          ::Platform::Object^ arg0 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::UI::Xaml::PropertyChangedCallback^ arg1 = dynamic_cast<::Windows::UI::Xaml::PropertyChangedCallback^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          winRtInstance = ref new ::Windows::UI::Xaml::PropertyMetadata(arg0,arg1);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      PropertyMetadata *wrapperInstance = new PropertyMetadata(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::PropertyMetadata^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::PropertyMetadata^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::PropertyMetadata^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapPropertyMetadata(winRtInstance));
    }





    static void Create(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[0]))
      {
        try
        {
          ::Platform::Object^ arg0 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::UI::Xaml::PropertyMetadata^ result;
          result = ::Windows::UI::Xaml::PropertyMetadata::Create(arg0);
          info.GetReturnValue().Set(WrapPropertyMetadata(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::PropertyChangedCallback^>(info[1]))
      {
        try
        {
          ::Platform::Object^ arg0 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::UI::Xaml::PropertyChangedCallback^ arg1 = dynamic_cast<::Windows::UI::Xaml::PropertyChangedCallback^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          ::Windows::UI::Xaml::PropertyMetadata^ result;
          result = ::Windows::UI::Xaml::PropertyMetadata::Create(arg0, arg1);
          info.GetReturnValue().Set(WrapPropertyMetadata(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::CreateDefaultValueCallback^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::CreateDefaultValueCallback^ arg0 = dynamic_cast<::Windows::UI::Xaml::CreateDefaultValueCallback^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::UI::Xaml::PropertyMetadata^ result;
          result = ::Windows::UI::Xaml::PropertyMetadata::Create(arg0);
          info.GetReturnValue().Set(WrapPropertyMetadata(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::CreateDefaultValueCallback^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::PropertyChangedCallback^>(info[1]))
      {
        try
        {
          ::Windows::UI::Xaml::CreateDefaultValueCallback^ arg0 = dynamic_cast<::Windows::UI::Xaml::CreateDefaultValueCallback^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::UI::Xaml::PropertyChangedCallback^ arg1 = dynamic_cast<::Windows::UI::Xaml::PropertyChangedCallback^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          ::Windows::UI::Xaml::PropertyMetadata^ result;
          result = ::Windows::UI::Xaml::PropertyMetadata::Create(arg0, arg1);
          info.GetReturnValue().Set(WrapPropertyMetadata(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void CreateDefaultValueCallbackGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::PropertyMetadata^>(info.This())) {
        return;
      }

      PropertyMetadata *wrapper = PropertyMetadata::Unwrap<PropertyMetadata>(info.This());

      try  {
        ::Windows::UI::Xaml::CreateDefaultValueCallback^ result = wrapper->_instance->CreateDefaultValueCallback;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml", "CreateDefaultValueCallback", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DefaultValueGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::PropertyMetadata^>(info.This())) {
        return;
      }

      PropertyMetadata *wrapper = PropertyMetadata::Unwrap<PropertyMetadata>(info.This());

      try  {
        ::Platform::Object^ result = wrapper->_instance->DefaultValue;
        info.GetReturnValue().Set(CreateOpaqueWrapper(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::PropertyMetadata^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPropertyMetadata(::Windows::UI::Xaml::PropertyMetadata^ wintRtInstance);
      friend ::Windows::UI::Xaml::PropertyMetadata^ UnwrapPropertyMetadata(Local<Value> value);
  };

  Persistent<FunctionTemplate> PropertyMetadata::s_constructorTemplate;

  v8::Local<v8::Value> WrapPropertyMetadata(::Windows::UI::Xaml::PropertyMetadata^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(PropertyMetadata::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::PropertyMetadata^ UnwrapPropertyMetadata(Local<Value> value) {
     return PropertyMetadata::Unwrap<PropertyMetadata>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPropertyMetadata(Local<Object> exports) {
    PropertyMetadata::Init(exports);
  }

  class PropertyPath : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("PropertyPath").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("path").ToLocalChecked(), PathGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("PropertyPath").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      PropertyPath(::Windows::UI::Xaml::PropertyPath^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::PropertyPath^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::PropertyPath^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::PropertyPath^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && info[0]->IsString())
      {
        try {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          winRtInstance = ref new ::Windows::UI::Xaml::PropertyPath(arg0);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      PropertyPath *wrapperInstance = new PropertyPath(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::PropertyPath^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::PropertyPath^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::PropertyPath^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapPropertyPath(winRtInstance));
    }





    static void PathGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::PropertyPath^>(info.This())) {
        return;
      }

      PropertyPath *wrapper = PropertyPath::Unwrap<PropertyPath>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Path;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DispatcherGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      try  {
        ::Windows::UI::Core::CoreDispatcher^ result = wrapper->_instance->Dispatcher;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "CoreDispatcher", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::PropertyPath^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPropertyPath(::Windows::UI::Xaml::PropertyPath^ wintRtInstance);
      friend ::Windows::UI::Xaml::PropertyPath^ UnwrapPropertyPath(Local<Value> value);
  };

  Persistent<FunctionTemplate> PropertyPath::s_constructorTemplate;

  v8::Local<v8::Value> WrapPropertyPath(::Windows::UI::Xaml::PropertyPath^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(PropertyPath::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::PropertyPath^ UnwrapPropertyPath(Local<Value> value) {
     return PropertyPath::Unwrap<PropertyPath>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPropertyPath(Local<Object> exports) {
    PropertyPath::Init(exports);
  }

  class RectHelper : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("RectHelper").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);






        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetMethod(constructor, "fromCoordinatesAndDimensions", FromCoordinatesAndDimensions);
        Nan::SetMethod(constructor, "fromPoints", FromPoints);
        Nan::SetMethod(constructor, "fromLocationAndSize", FromLocationAndSize);
        Nan::SetMethod(constructor, "getIsEmpty", GetIsEmpty);
        Nan::SetMethod(constructor, "getBottom", GetBottom);
        Nan::SetMethod(constructor, "getLeft", GetLeft);
        Nan::SetMethod(constructor, "getRight", GetRight);
        Nan::SetMethod(constructor, "getTop", GetTop);
        Nan::SetMethod(constructor, "contains", Contains);
        Nan::SetMethod(constructor, "equals", Equals);
        Nan::SetMethod(constructor, "intersect", Intersect);
        Nan::SetMethod(constructor, "union", Union);
        Nan::SetAccessor(constructor, Nan::New<String>("empty").ToLocalChecked(), EmptyGetter);


        Nan::Set(exports, Nan::New<String>("RectHelper").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      RectHelper(::Windows::UI::Xaml::RectHelper^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::RectHelper^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::RectHelper^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::RectHelper^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      RectHelper *wrapperInstance = new RectHelper(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::RectHelper^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::RectHelper^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::RectHelper^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapRectHelper(winRtInstance));
    }





    static void FromCoordinatesAndDimensions(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 4
        && info[0]->IsNumber()
        && info[1]->IsNumber()
        && info[2]->IsNumber()
        && info[3]->IsNumber())
      {
        try
        {
          float arg0 = static_cast<float>(Nan::To<double>(info[0]).FromMaybe(0.0));
          float arg1 = static_cast<float>(Nan::To<double>(info[1]).FromMaybe(0.0));
          float arg2 = static_cast<float>(Nan::To<double>(info[2]).FromMaybe(0.0));
          float arg3 = static_cast<float>(Nan::To<double>(info[3]).FromMaybe(0.0));
          
          ::Windows::Foundation::Rect result;
          result = ::Windows::UI::Xaml::RectHelper::FromCoordinatesAndDimensions(arg0, arg1, arg2, arg3);
          info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void FromPoints(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && NodeRT::Utils::IsPoint(info[0])
        && NodeRT::Utils::IsPoint(info[1]))
      {
        try
        {
          ::Windows::Foundation::Point arg0 = NodeRT::Utils::PointFromJs(info[0]);
          ::Windows::Foundation::Point arg1 = NodeRT::Utils::PointFromJs(info[1]);
          
          ::Windows::Foundation::Rect result;
          result = ::Windows::UI::Xaml::RectHelper::FromPoints(arg0, arg1);
          info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void FromLocationAndSize(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && NodeRT::Utils::IsPoint(info[0])
        && NodeRT::Utils::IsSize(info[1]))
      {
        try
        {
          ::Windows::Foundation::Point arg0 = NodeRT::Utils::PointFromJs(info[0]);
          ::Windows::Foundation::Size arg1 = NodeRT::Utils::SizeFromJs(info[1]);
          
          ::Windows::Foundation::Rect result;
          result = ::Windows::UI::Xaml::RectHelper::FromLocationAndSize(arg0, arg1);
          info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void GetIsEmpty(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && NodeRT::Utils::IsRect(info[0]))
      {
        try
        {
          ::Windows::Foundation::Rect arg0 = NodeRT::Utils::RectFromJs(info[0]);
          
          bool result;
          result = ::Windows::UI::Xaml::RectHelper::GetIsEmpty(arg0);
          info.GetReturnValue().Set(Nan::New<Boolean>(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void GetBottom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && NodeRT::Utils::IsRect(info[0]))
      {
        try
        {
          ::Windows::Foundation::Rect arg0 = NodeRT::Utils::RectFromJs(info[0]);
          
          float result;
          result = ::Windows::UI::Xaml::RectHelper::GetBottom(arg0);
          info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void GetLeft(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && NodeRT::Utils::IsRect(info[0]))
      {
        try
        {
          ::Windows::Foundation::Rect arg0 = NodeRT::Utils::RectFromJs(info[0]);
          
          float result;
          result = ::Windows::UI::Xaml::RectHelper::GetLeft(arg0);
          info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void GetRight(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && NodeRT::Utils::IsRect(info[0]))
      {
        try
        {
          ::Windows::Foundation::Rect arg0 = NodeRT::Utils::RectFromJs(info[0]);
          
          float result;
          result = ::Windows::UI::Xaml::RectHelper::GetRight(arg0);
          info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void GetTop(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && NodeRT::Utils::IsRect(info[0]))
      {
        try
        {
          ::Windows::Foundation::Rect arg0 = NodeRT::Utils::RectFromJs(info[0]);
          
          float result;
          result = ::Windows::UI::Xaml::RectHelper::GetTop(arg0);
          info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void Contains(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && NodeRT::Utils::IsRect(info[0])
        && NodeRT::Utils::IsPoint(info[1]))
      {
        try
        {
          ::Windows::Foundation::Rect arg0 = NodeRT::Utils::RectFromJs(info[0]);
          ::Windows::Foundation::Point arg1 = NodeRT::Utils::PointFromJs(info[1]);
          
          bool result;
          result = ::Windows::UI::Xaml::RectHelper::Contains(arg0, arg1);
          info.GetReturnValue().Set(Nan::New<Boolean>(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void Equals(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && NodeRT::Utils::IsRect(info[0])
        && NodeRT::Utils::IsRect(info[1]))
      {
        try
        {
          ::Windows::Foundation::Rect arg0 = NodeRT::Utils::RectFromJs(info[0]);
          ::Windows::Foundation::Rect arg1 = NodeRT::Utils::RectFromJs(info[1]);
          
          bool result;
          result = ::Windows::UI::Xaml::RectHelper::Equals(arg0, arg1);
          info.GetReturnValue().Set(Nan::New<Boolean>(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void Intersect(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && NodeRT::Utils::IsRect(info[0])
        && NodeRT::Utils::IsRect(info[1]))
      {
        try
        {
          ::Windows::Foundation::Rect arg0 = NodeRT::Utils::RectFromJs(info[0]);
          ::Windows::Foundation::Rect arg1 = NodeRT::Utils::RectFromJs(info[1]);
          
          ::Windows::Foundation::Rect result;
          result = ::Windows::UI::Xaml::RectHelper::Intersect(arg0, arg1);
          info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void Union(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && NodeRT::Utils::IsRect(info[0])
        && NodeRT::Utils::IsPoint(info[1]))
      {
        try
        {
          ::Windows::Foundation::Rect arg0 = NodeRT::Utils::RectFromJs(info[0]);
          ::Windows::Foundation::Point arg1 = NodeRT::Utils::PointFromJs(info[1]);
          
          ::Windows::Foundation::Rect result;
          result = ::Windows::UI::Xaml::RectHelper::Union(arg0, arg1);
          info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && NodeRT::Utils::IsRect(info[0])
        && NodeRT::Utils::IsRect(info[1]))
      {
        try
        {
          ::Windows::Foundation::Rect arg0 = NodeRT::Utils::RectFromJs(info[0]);
          ::Windows::Foundation::Rect arg1 = NodeRT::Utils::RectFromJs(info[1]);
          
          ::Windows::Foundation::Rect result;
          result = ::Windows::UI::Xaml::RectHelper::Union(arg0, arg1);
          info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    static void EmptyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::Foundation::Rect result = ::Windows::UI::Xaml::RectHelper::Empty;
        info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    private:
      ::Windows::UI::Xaml::RectHelper^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapRectHelper(::Windows::UI::Xaml::RectHelper^ wintRtInstance);
      friend ::Windows::UI::Xaml::RectHelper^ UnwrapRectHelper(Local<Value> value);
  };

  Persistent<FunctionTemplate> RectHelper::s_constructorTemplate;

  v8::Local<v8::Value> WrapRectHelper(::Windows::UI::Xaml::RectHelper^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(RectHelper::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::RectHelper^ UnwrapRectHelper(Local<Value> value) {
     return RectHelper::Unwrap<RectHelper>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitRectHelper(Local<Object> exports) {
    RectHelper::Init(exports);
  }

  class RoutedEvent : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("RoutedEvent").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);






        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("RoutedEvent").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      RoutedEvent(::Windows::UI::Xaml::RoutedEvent^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::RoutedEvent^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::RoutedEvent^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::RoutedEvent^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      RoutedEvent *wrapperInstance = new RoutedEvent(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::RoutedEvent^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::RoutedEvent^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::RoutedEvent^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapRoutedEvent(winRtInstance));
    }







    private:
      ::Windows::UI::Xaml::RoutedEvent^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapRoutedEvent(::Windows::UI::Xaml::RoutedEvent^ wintRtInstance);
      friend ::Windows::UI::Xaml::RoutedEvent^ UnwrapRoutedEvent(Local<Value> value);
  };

  Persistent<FunctionTemplate> RoutedEvent::s_constructorTemplate;

  v8::Local<v8::Value> WrapRoutedEvent(::Windows::UI::Xaml::RoutedEvent^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(RoutedEvent::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::RoutedEvent^ UnwrapRoutedEvent(Local<Value> value) {
     return RoutedEvent::Unwrap<RoutedEvent>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitRoutedEvent(Local<Object> exports) {
    RoutedEvent::Init(exports);
  }

  class ScalarTransition : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("ScalarTransition").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("duration").ToLocalChecked(), DurationGetter, DurationSetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ScalarTransition").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ScalarTransition(::Windows::UI::Xaml::ScalarTransition^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::ScalarTransition^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ScalarTransition^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::ScalarTransition^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::ScalarTransition();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      ScalarTransition *wrapperInstance = new ScalarTransition(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ScalarTransition^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::ScalarTransition^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::ScalarTransition^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapScalarTransition(winRtInstance));
    }





    static void DurationGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ScalarTransition^>(info.This())) {
        return;
      }

      ScalarTransition *wrapper = ScalarTransition::Unwrap<ScalarTransition>(info.This());

      try  {
        ::Windows::Foundation::TimeSpan result = wrapper->_instance->Duration;
        info.GetReturnValue().Set(Nan::New<Number>(result.Duration/10000.0));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DurationSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::ScalarTransition^>(info.This())) {
        return;
      }

      ScalarTransition *wrapper = ScalarTransition::Unwrap<ScalarTransition>(info.This());

      try {

        ::Windows::Foundation::TimeSpan winRtValue = NodeRT::Utils::TimeSpanFromMilli(Nan::To<int64_t>(value).FromMaybe(0));

        wrapper->_instance->Duration = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      


    private:
      ::Windows::UI::Xaml::ScalarTransition^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapScalarTransition(::Windows::UI::Xaml::ScalarTransition^ wintRtInstance);
      friend ::Windows::UI::Xaml::ScalarTransition^ UnwrapScalarTransition(Local<Value> value);
  };

  Persistent<FunctionTemplate> ScalarTransition::s_constructorTemplate;

  v8::Local<v8::Value> WrapScalarTransition(::Windows::UI::Xaml::ScalarTransition^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(ScalarTransition::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::ScalarTransition^ UnwrapScalarTransition(Local<Value> value) {
     return ScalarTransition::Unwrap<ScalarTransition>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitScalarTransition(Local<Object> exports) {
    ScalarTransition::Init(exports);
  }

  class SetterBase : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("SetterBase").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isSealed").ToLocalChecked(), IsSealedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("SetterBase").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      SetterBase(::Windows::UI::Xaml::SetterBase^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::SetterBase^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SetterBase^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::SetterBase^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      SetterBase *wrapperInstance = new SetterBase(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SetterBase^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::SetterBase^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::SetterBase^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapSetterBase(winRtInstance));
    }





    static void IsSealedGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SetterBase^>(info.This())) {
        return;
      }

      SetterBase *wrapper = SetterBase::Unwrap<SetterBase>(info.This());

      try  {
        bool result = wrapper->_instance->IsSealed;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DispatcherGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      try  {
        ::Windows::UI::Core::CoreDispatcher^ result = wrapper->_instance->Dispatcher;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "CoreDispatcher", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::SetterBase^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapSetterBase(::Windows::UI::Xaml::SetterBase^ wintRtInstance);
      friend ::Windows::UI::Xaml::SetterBase^ UnwrapSetterBase(Local<Value> value);
  };

  Persistent<FunctionTemplate> SetterBase::s_constructorTemplate;

  v8::Local<v8::Value> WrapSetterBase(::Windows::UI::Xaml::SetterBase^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(SetterBase::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::SetterBase^ UnwrapSetterBase(Local<Value> value) {
     return SetterBase::Unwrap<SetterBase>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitSetterBase(Local<Object> exports) {
    SetterBase::Init(exports);
  }

  class Setter : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("Setter").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("value").ToLocalChecked(), ValueGetter, ValueSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("property").ToLocalChecked(), PropertyGetter, PropertySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("target").ToLocalChecked(), TargetGetter, TargetSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isSealed").ToLocalChecked(), IsSealedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("Setter").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      Setter(::Windows::UI::Xaml::Setter^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::Setter^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Setter^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::Setter^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyProperty^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[1]))
      {
        try {
          ::Windows::UI::Xaml::DependencyProperty^ arg0 = UnwrapDependencyProperty(info[0]);
          ::Platform::Object^ arg1 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          winRtInstance = ref new ::Windows::UI::Xaml::Setter(arg0,arg1);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::Setter();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      Setter *wrapperInstance = new Setter(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Setter^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::Setter^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::Setter^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapSetter(winRtInstance));
    }





    static void ValueGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Setter^>(info.This())) {
        return;
      }

      Setter *wrapper = Setter::Unwrap<Setter>(info.This());

      try  {
        ::Platform::Object^ result = wrapper->_instance->Value;
        info.GetReturnValue().Set(CreateOpaqueWrapper(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ValueSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Setter^>(info.This())) {
        return;
      }

      Setter *wrapper = Setter::Unwrap<Setter>(info.This());

      try {

        ::Platform::Object^ winRtValue = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Value = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void PropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Setter^>(info.This())) {
        return;
      }

      Setter *wrapper = Setter::Unwrap<Setter>(info.This());

      try  {
        ::Windows::UI::Xaml::DependencyProperty^ result = wrapper->_instance->Property;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PropertySetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyProperty^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Setter^>(info.This())) {
        return;
      }

      Setter *wrapper = Setter::Unwrap<Setter>(info.This());

      try {

        ::Windows::UI::Xaml::DependencyProperty^ winRtValue = dynamic_cast<::Windows::UI::Xaml::DependencyProperty^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Property = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void TargetGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Setter^>(info.This())) {
        return;
      }

      Setter *wrapper = Setter::Unwrap<Setter>(info.This());

      try  {
        ::Windows::UI::Xaml::TargetPropertyPath^ result = wrapper->_instance->Target;
        info.GetReturnValue().Set(WrapTargetPropertyPath(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TargetSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TargetPropertyPath^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Setter^>(info.This())) {
        return;
      }

      Setter *wrapper = Setter::Unwrap<Setter>(info.This());

      try {

        ::Windows::UI::Xaml::TargetPropertyPath^ winRtValue = dynamic_cast<::Windows::UI::Xaml::TargetPropertyPath^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Target = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsSealedGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SetterBase^>(info.This())) {
        return;
      }

      SetterBase *wrapper = SetterBase::Unwrap<SetterBase>(info.This());

      try  {
        bool result = wrapper->_instance->IsSealed;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DispatcherGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      try  {
        ::Windows::UI::Core::CoreDispatcher^ result = wrapper->_instance->Dispatcher;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "CoreDispatcher", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::Setter^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapSetter(::Windows::UI::Xaml::Setter^ wintRtInstance);
      friend ::Windows::UI::Xaml::Setter^ UnwrapSetter(Local<Value> value);
  };

  Persistent<FunctionTemplate> Setter::s_constructorTemplate;

  v8::Local<v8::Value> WrapSetter(::Windows::UI::Xaml::Setter^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(Setter::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::Setter^ UnwrapSetter(Local<Value> value) {
     return Setter::Unwrap<Setter>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitSetter(Local<Object> exports) {
    Setter::Init(exports);
  }

  class SetterBaseCollection : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("SetterBaseCollection").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "getAt", GetAt);
            Nan::SetPrototypeMethod(localRef, "getView", GetView);
            Nan::SetPrototypeMethod(localRef, "indexOf", IndexOf);
            Nan::SetPrototypeMethod(localRef, "setAt", SetAt);
            Nan::SetPrototypeMethod(localRef, "insertAt", InsertAt);
            Nan::SetPrototypeMethod(localRef, "removeAt", RemoveAt);
            Nan::SetPrototypeMethod(localRef, "append", Append);
            Nan::SetPrototypeMethod(localRef, "removeAtEnd", RemoveAtEnd);
            Nan::SetPrototypeMethod(localRef, "clear", Clear);
            Nan::SetPrototypeMethod(localRef, "getMany", GetMany);
            Nan::SetPrototypeMethod(localRef, "replaceAll", ReplaceAll);
            Nan::SetPrototypeMethod(localRef, "first", First);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isSealed").ToLocalChecked(), IsSealedGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("SetterBaseCollection").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      SetterBaseCollection(::Windows::UI::Xaml::SetterBaseCollection^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::SetterBaseCollection^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SetterBaseCollection^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::SetterBaseCollection^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::SetterBaseCollection();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      SetterBaseCollection *wrapperInstance = new SetterBaseCollection(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SetterBaseCollection^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::SetterBaseCollection^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::SetterBaseCollection^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapSetterBaseCollection(winRtInstance));
    }


    static void GetAt(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SetterBaseCollection^>(info.This())) {
        return;
      }

      SetterBaseCollection *wrapper = SetterBaseCollection::Unwrap<SetterBaseCollection>(info.This());

      if (info.Length() == 1
        && info[0]->IsUint32())
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          
          ::Windows::UI::Xaml::SetterBase^ result;
          result = wrapper->_instance->GetAt(arg0);
          info.GetReturnValue().Set(WrapSetterBase(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetView(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SetterBaseCollection^>(info.This())) {
        return;
      }

      SetterBaseCollection *wrapper = SetterBaseCollection::Unwrap<SetterBaseCollection>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Xaml::SetterBase^>^ result;
          result = wrapper->_instance->GetView();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Xaml::SetterBase^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Xaml::SetterBase^ val) -> Local<Value> {
              return WrapSetterBase(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SetterBase^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Xaml::SetterBase^ {
              return UnwrapSetterBase(value);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void IndexOf(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SetterBaseCollection^>(info.This())) {
        return;
      }

      SetterBaseCollection *wrapper = SetterBaseCollection::Unwrap<SetterBaseCollection>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SetterBase^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::SetterBase^ arg0 = UnwrapSetterBase(info[0]);
          unsigned int arg1;
          
          bool result;
          result = wrapper->_instance->IndexOf(arg0, &arg1);
          Local<Object> resObj = Nan::New<Object>();
          Nan::Set(resObj, Nan::New<String>("boolean").ToLocalChecked(), Nan::New<Boolean>(result));
          Nan::Set(resObj, Nan::New<String>("index").ToLocalChecked(), Nan::New<Integer>(arg1));
          info.GetReturnValue().Set(resObj);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void SetAt(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SetterBaseCollection^>(info.This())) {
        return;
      }

      SetterBaseCollection *wrapper = SetterBaseCollection::Unwrap<SetterBaseCollection>(info.This());

      if (info.Length() == 2
        && info[0]->IsUint32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SetterBase^>(info[1]))
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          ::Windows::UI::Xaml::SetterBase^ arg1 = UnwrapSetterBase(info[1]);
          
          wrapper->_instance->SetAt(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void InsertAt(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SetterBaseCollection^>(info.This())) {
        return;
      }

      SetterBaseCollection *wrapper = SetterBaseCollection::Unwrap<SetterBaseCollection>(info.This());

      if (info.Length() == 2
        && info[0]->IsUint32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SetterBase^>(info[1]))
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          ::Windows::UI::Xaml::SetterBase^ arg1 = UnwrapSetterBase(info[1]);
          
          wrapper->_instance->InsertAt(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void RemoveAt(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SetterBaseCollection^>(info.This())) {
        return;
      }

      SetterBaseCollection *wrapper = SetterBaseCollection::Unwrap<SetterBaseCollection>(info.This());

      if (info.Length() == 1
        && info[0]->IsUint32())
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          
          wrapper->_instance->RemoveAt(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Append(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SetterBaseCollection^>(info.This())) {
        return;
      }

      SetterBaseCollection *wrapper = SetterBaseCollection::Unwrap<SetterBaseCollection>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SetterBase^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::SetterBase^ arg0 = UnwrapSetterBase(info[0]);
          
          wrapper->_instance->Append(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void RemoveAtEnd(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SetterBaseCollection^>(info.This())) {
        return;
      }

      SetterBaseCollection *wrapper = SetterBaseCollection::Unwrap<SetterBaseCollection>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->RemoveAtEnd();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Clear(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SetterBaseCollection^>(info.This())) {
        return;
      }

      SetterBaseCollection *wrapper = SetterBaseCollection::Unwrap<SetterBaseCollection>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->Clear();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetMany(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Not implemented")));
    }
    static void ReplaceAll(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SetterBaseCollection^>(info.This())) {
        return;
      }

      SetterBaseCollection *wrapper = SetterBaseCollection::Unwrap<SetterBaseCollection>(info.This());

      if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<::Windows::UI::Xaml::SetterBase^>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Platform::Array<::Windows::UI::Xaml::SetterBase^>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<::Windows::UI::Xaml::SetterBase^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<::Windows::UI::Xaml::SetterBase^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SetterBase^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::UI::Xaml::SetterBase^ {
                   return UnwrapSetterBase(value);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<::Windows::UI::Xaml::SetterBase^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          wrapper->_instance->ReplaceAll(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void First(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SetterBaseCollection^>(info.This())) {
        return;
      }

      SetterBaseCollection *wrapper = SetterBaseCollection::Unwrap<SetterBaseCollection>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IIterator<::Windows::UI::Xaml::SetterBase^>^ result;
          result = wrapper->_instance->First();
          info.GetReturnValue().Set(NodeRT::Collections::IteratorWrapper<::Windows::UI::Xaml::SetterBase^>::CreateIteratorWrapper(result, 
            [](::Windows::UI::Xaml::SetterBase^ val) -> Local<Value> {
              return WrapSetterBase(val);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    static void IsSealedGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SetterBaseCollection^>(info.This())) {
        return;
      }

      SetterBaseCollection *wrapper = SetterBaseCollection::Unwrap<SetterBaseCollection>(info.This());

      try  {
        bool result = wrapper->_instance->IsSealed;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::SetterBaseCollection^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapSetterBaseCollection(::Windows::UI::Xaml::SetterBaseCollection^ wintRtInstance);
      friend ::Windows::UI::Xaml::SetterBaseCollection^ UnwrapSetterBaseCollection(Local<Value> value);
  };

  Persistent<FunctionTemplate> SetterBaseCollection::s_constructorTemplate;

  v8::Local<v8::Value> WrapSetterBaseCollection(::Windows::UI::Xaml::SetterBaseCollection^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(SetterBaseCollection::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::SetterBaseCollection^ UnwrapSetterBaseCollection(Local<Value> value) {
     return SetterBaseCollection::Unwrap<SetterBaseCollection>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitSetterBaseCollection(Local<Object> exports) {
    SetterBaseCollection::Init(exports);
  }

  class SizeChangedEventArgs : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("SizeChangedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("newSize").ToLocalChecked(), NewSizeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("previousSize").ToLocalChecked(), PreviousSizeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("originalSource").ToLocalChecked(), OriginalSourceGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("SizeChangedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      SizeChangedEventArgs(::Windows::UI::Xaml::SizeChangedEventArgs^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::SizeChangedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SizeChangedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::SizeChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      SizeChangedEventArgs *wrapperInstance = new SizeChangedEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SizeChangedEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::SizeChangedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::SizeChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapSizeChangedEventArgs(winRtInstance));
    }





    static void NewSizeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SizeChangedEventArgs^>(info.This())) {
        return;
      }

      SizeChangedEventArgs *wrapper = SizeChangedEventArgs::Unwrap<SizeChangedEventArgs>(info.This());

      try  {
        ::Windows::Foundation::Size result = wrapper->_instance->NewSize;
        info.GetReturnValue().Set(NodeRT::Utils::SizeToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PreviousSizeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SizeChangedEventArgs^>(info.This())) {
        return;
      }

      SizeChangedEventArgs *wrapper = SizeChangedEventArgs::Unwrap<SizeChangedEventArgs>(info.This());

      try  {
        ::Windows::Foundation::Size result = wrapper->_instance->PreviousSize;
        info.GetReturnValue().Set(NodeRT::Utils::SizeToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void OriginalSourceGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::RoutedEventArgs^>(info.This())) {
        return;
      }

      RoutedEventArgs *wrapper = RoutedEventArgs::Unwrap<RoutedEventArgs>(info.This());

      try  {
        ::Platform::Object^ result = wrapper->_instance->OriginalSource;
        info.GetReturnValue().Set(CreateOpaqueWrapper(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::SizeChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapSizeChangedEventArgs(::Windows::UI::Xaml::SizeChangedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Xaml::SizeChangedEventArgs^ UnwrapSizeChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> SizeChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapSizeChangedEventArgs(::Windows::UI::Xaml::SizeChangedEventArgs^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(SizeChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::SizeChangedEventArgs^ UnwrapSizeChangedEventArgs(Local<Value> value) {
     return SizeChangedEventArgs::Unwrap<SizeChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitSizeChangedEventArgs(Local<Object> exports) {
    SizeChangedEventArgs::Init(exports);
  }

  class SizeHelper : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("SizeHelper").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);






        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetMethod(constructor, "fromDimensions", FromDimensions);
        Nan::SetMethod(constructor, "getIsEmpty", GetIsEmpty);
        Nan::SetMethod(constructor, "equals", Equals);
        Nan::SetAccessor(constructor, Nan::New<String>("empty").ToLocalChecked(), EmptyGetter);


        Nan::Set(exports, Nan::New<String>("SizeHelper").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      SizeHelper(::Windows::UI::Xaml::SizeHelper^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::SizeHelper^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SizeHelper^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::SizeHelper^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      SizeHelper *wrapperInstance = new SizeHelper(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::SizeHelper^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::SizeHelper^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::SizeHelper^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapSizeHelper(winRtInstance));
    }





    static void FromDimensions(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && info[0]->IsNumber()
        && info[1]->IsNumber())
      {
        try
        {
          float arg0 = static_cast<float>(Nan::To<double>(info[0]).FromMaybe(0.0));
          float arg1 = static_cast<float>(Nan::To<double>(info[1]).FromMaybe(0.0));
          
          ::Windows::Foundation::Size result;
          result = ::Windows::UI::Xaml::SizeHelper::FromDimensions(arg0, arg1);
          info.GetReturnValue().Set(NodeRT::Utils::SizeToJs(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void GetIsEmpty(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && NodeRT::Utils::IsSize(info[0]))
      {
        try
        {
          ::Windows::Foundation::Size arg0 = NodeRT::Utils::SizeFromJs(info[0]);
          
          bool result;
          result = ::Windows::UI::Xaml::SizeHelper::GetIsEmpty(arg0);
          info.GetReturnValue().Set(Nan::New<Boolean>(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void Equals(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && NodeRT::Utils::IsSize(info[0])
        && NodeRT::Utils::IsSize(info[1]))
      {
        try
        {
          ::Windows::Foundation::Size arg0 = NodeRT::Utils::SizeFromJs(info[0]);
          ::Windows::Foundation::Size arg1 = NodeRT::Utils::SizeFromJs(info[1]);
          
          bool result;
          result = ::Windows::UI::Xaml::SizeHelper::Equals(arg0, arg1);
          info.GetReturnValue().Set(Nan::New<Boolean>(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    static void EmptyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::Foundation::Size result = ::Windows::UI::Xaml::SizeHelper::Empty;
        info.GetReturnValue().Set(NodeRT::Utils::SizeToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    private:
      ::Windows::UI::Xaml::SizeHelper^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapSizeHelper(::Windows::UI::Xaml::SizeHelper^ wintRtInstance);
      friend ::Windows::UI::Xaml::SizeHelper^ UnwrapSizeHelper(Local<Value> value);
  };

  Persistent<FunctionTemplate> SizeHelper::s_constructorTemplate;

  v8::Local<v8::Value> WrapSizeHelper(::Windows::UI::Xaml::SizeHelper^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(SizeHelper::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::SizeHelper^ UnwrapSizeHelper(Local<Value> value) {
     return SizeHelper::Unwrap<SizeHelper>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitSizeHelper(Local<Object> exports) {
    SizeHelper::Init(exports);
  }

  class StateTrigger : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("StateTrigger").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isActive").ToLocalChecked(), IsActiveGetter, IsActiveSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetAccessor(constructor, Nan::New<String>("isActiveProperty").ToLocalChecked(), IsActivePropertyGetter);


        Nan::Set(exports, Nan::New<String>("StateTrigger").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      StateTrigger(::Windows::UI::Xaml::StateTrigger^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::StateTrigger^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::StateTrigger^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::StateTrigger^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::StateTrigger();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      StateTrigger *wrapperInstance = new StateTrigger(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::StateTrigger^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::StateTrigger^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::StateTrigger^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapStateTrigger(winRtInstance));
    }





    static void IsActiveGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::StateTrigger^>(info.This())) {
        return;
      }

      StateTrigger *wrapper = StateTrigger::Unwrap<StateTrigger>(info.This());

      try  {
        bool result = wrapper->_instance->IsActive;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsActiveSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::StateTrigger^>(info.This())) {
        return;
      }

      StateTrigger *wrapper = StateTrigger::Unwrap<StateTrigger>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsActive = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void DispatcherGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      try  {
        ::Windows::UI::Core::CoreDispatcher^ result = wrapper->_instance->Dispatcher;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "CoreDispatcher", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    static void IsActivePropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::StateTrigger::IsActiveProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    private:
      ::Windows::UI::Xaml::StateTrigger^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapStateTrigger(::Windows::UI::Xaml::StateTrigger^ wintRtInstance);
      friend ::Windows::UI::Xaml::StateTrigger^ UnwrapStateTrigger(Local<Value> value);
  };

  Persistent<FunctionTemplate> StateTrigger::s_constructorTemplate;

  v8::Local<v8::Value> WrapStateTrigger(::Windows::UI::Xaml::StateTrigger^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(StateTrigger::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::StateTrigger^ UnwrapStateTrigger(Local<Value> value) {
     return StateTrigger::Unwrap<StateTrigger>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitStateTrigger(Local<Object> exports) {
    StateTrigger::Init(exports);
  }

  class Style : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("Style").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "seal", Seal);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("targetType").ToLocalChecked(), TargetTypeGetter, TargetTypeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("basedOn").ToLocalChecked(), BasedOnGetter, BasedOnSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isSealed").ToLocalChecked(), IsSealedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("setters").ToLocalChecked(), SettersGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("Style").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      Style(::Windows::UI::Xaml::Style^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::Style^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Style^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::Style^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Type^>(info[0]))
      {
        try {
          ::Platform::Type^ arg0 = dynamic_cast<::Platform::Type^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          winRtInstance = ref new ::Windows::UI::Xaml::Style(arg0);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::Style();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      Style *wrapperInstance = new Style(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Style^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::Style^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::Style^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapStyle(winRtInstance));
    }


    static void Seal(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Style^>(info.This())) {
        return;
      }

      Style *wrapper = Style::Unwrap<Style>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->Seal();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    static void TargetTypeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Style^>(info.This())) {
        return;
      }

      Style *wrapper = Style::Unwrap<Style>(info.This());

      try  {
        ::Platform::Type^ result = wrapper->_instance->TargetType;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("System", "Type", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TargetTypeSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Platform::Type^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Style^>(info.This())) {
        return;
      }

      Style *wrapper = Style::Unwrap<Style>(info.This());

      try {

        ::Platform::Type^ winRtValue = dynamic_cast<::Platform::Type^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->TargetType = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void BasedOnGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Style^>(info.This())) {
        return;
      }

      Style *wrapper = Style::Unwrap<Style>(info.This());

      try  {
        ::Windows::UI::Xaml::Style^ result = wrapper->_instance->BasedOn;
        info.GetReturnValue().Set(WrapStyle(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BasedOnSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Style^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Style^>(info.This())) {
        return;
      }

      Style *wrapper = Style::Unwrap<Style>(info.This());

      try {

        ::Windows::UI::Xaml::Style^ winRtValue = dynamic_cast<::Windows::UI::Xaml::Style^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->BasedOn = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsSealedGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Style^>(info.This())) {
        return;
      }

      Style *wrapper = Style::Unwrap<Style>(info.This());

      try  {
        bool result = wrapper->_instance->IsSealed;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SettersGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Style^>(info.This())) {
        return;
      }

      Style *wrapper = Style::Unwrap<Style>(info.This());

      try  {
        ::Windows::UI::Xaml::SetterBaseCollection^ result = wrapper->_instance->Setters;
        info.GetReturnValue().Set(WrapSetterBaseCollection(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DispatcherGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      try  {
        ::Windows::UI::Core::CoreDispatcher^ result = wrapper->_instance->Dispatcher;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "CoreDispatcher", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::Style^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapStyle(::Windows::UI::Xaml::Style^ wintRtInstance);
      friend ::Windows::UI::Xaml::Style^ UnwrapStyle(Local<Value> value);
  };

  Persistent<FunctionTemplate> Style::s_constructorTemplate;

  v8::Local<v8::Value> WrapStyle(::Windows::UI::Xaml::Style^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(Style::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::Style^ UnwrapStyle(Local<Value> value) {
     return Style::Unwrap<Style>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitStyle(Local<Object> exports) {
    Style::Init(exports);
  }

  class StyleTypedPropertyAttribute : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("StyleTypedPropertyAttribute").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("typeId").ToLocalChecked(), TypeIdGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("StyleTypedPropertyAttribute").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      StyleTypedPropertyAttribute(::Windows::UI::Xaml::StyleTypedPropertyAttribute^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::StyleTypedPropertyAttribute^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::StyleTypedPropertyAttribute^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::StyleTypedPropertyAttribute^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::StyleTypedPropertyAttribute();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      StyleTypedPropertyAttribute *wrapperInstance = new StyleTypedPropertyAttribute(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::StyleTypedPropertyAttribute^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::StyleTypedPropertyAttribute^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::StyleTypedPropertyAttribute^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapStyleTypedPropertyAttribute(winRtInstance));
    }





    static void TypeIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Platform::Attribute^>(info.This())) {
        return;
      }

      Attribute *wrapper = Attribute::Unwrap<Attribute>(info.This());

      try  {
        ::Platform::Object^ result = wrapper->_instance->TypeId;
        info.GetReturnValue().Set(CreateOpaqueWrapper(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::StyleTypedPropertyAttribute^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapStyleTypedPropertyAttribute(::Windows::UI::Xaml::StyleTypedPropertyAttribute^ wintRtInstance);
      friend ::Windows::UI::Xaml::StyleTypedPropertyAttribute^ UnwrapStyleTypedPropertyAttribute(Local<Value> value);
  };

  Persistent<FunctionTemplate> StyleTypedPropertyAttribute::s_constructorTemplate;

  v8::Local<v8::Value> WrapStyleTypedPropertyAttribute(::Windows::UI::Xaml::StyleTypedPropertyAttribute^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(StyleTypedPropertyAttribute::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::StyleTypedPropertyAttribute^ UnwrapStyleTypedPropertyAttribute(Local<Value> value) {
     return StyleTypedPropertyAttribute::Unwrap<StyleTypedPropertyAttribute>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitStyleTypedPropertyAttribute(Local<Object> exports) {
    StyleTypedPropertyAttribute::Init(exports);
  }

  class TargetPropertyPath : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("TargetPropertyPath").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("target").ToLocalChecked(), TargetGetter, TargetSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("path").ToLocalChecked(), PathGetter, PathSetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("TargetPropertyPath").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      TargetPropertyPath(::Windows::UI::Xaml::TargetPropertyPath^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::TargetPropertyPath^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TargetPropertyPath^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::TargetPropertyPath^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyProperty^>(info[0]))
      {
        try {
          ::Windows::UI::Xaml::DependencyProperty^ arg0 = UnwrapDependencyProperty(info[0]);
          
          winRtInstance = ref new ::Windows::UI::Xaml::TargetPropertyPath(arg0);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::TargetPropertyPath();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      TargetPropertyPath *wrapperInstance = new TargetPropertyPath(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TargetPropertyPath^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::TargetPropertyPath^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::TargetPropertyPath^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapTargetPropertyPath(winRtInstance));
    }





    static void TargetGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TargetPropertyPath^>(info.This())) {
        return;
      }

      TargetPropertyPath *wrapper = TargetPropertyPath::Unwrap<TargetPropertyPath>(info.This());

      try  {
        ::Platform::Object^ result = wrapper->_instance->Target;
        info.GetReturnValue().Set(CreateOpaqueWrapper(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TargetSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TargetPropertyPath^>(info.This())) {
        return;
      }

      TargetPropertyPath *wrapper = TargetPropertyPath::Unwrap<TargetPropertyPath>(info.This());

      try {

        ::Platform::Object^ winRtValue = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Target = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void PathGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TargetPropertyPath^>(info.This())) {
        return;
      }

      TargetPropertyPath *wrapper = TargetPropertyPath::Unwrap<TargetPropertyPath>(info.This());

      try  {
        ::Windows::UI::Xaml::PropertyPath^ result = wrapper->_instance->Path;
        info.GetReturnValue().Set(WrapPropertyPath(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PathSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::PropertyPath^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TargetPropertyPath^>(info.This())) {
        return;
      }

      TargetPropertyPath *wrapper = TargetPropertyPath::Unwrap<TargetPropertyPath>(info.This());

      try {

        ::Windows::UI::Xaml::PropertyPath^ winRtValue = dynamic_cast<::Windows::UI::Xaml::PropertyPath^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Path = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      


    private:
      ::Windows::UI::Xaml::TargetPropertyPath^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapTargetPropertyPath(::Windows::UI::Xaml::TargetPropertyPath^ wintRtInstance);
      friend ::Windows::UI::Xaml::TargetPropertyPath^ UnwrapTargetPropertyPath(Local<Value> value);
  };

  Persistent<FunctionTemplate> TargetPropertyPath::s_constructorTemplate;

  v8::Local<v8::Value> WrapTargetPropertyPath(::Windows::UI::Xaml::TargetPropertyPath^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(TargetPropertyPath::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::TargetPropertyPath^ UnwrapTargetPropertyPath(Local<Value> value) {
     return TargetPropertyPath::Unwrap<TargetPropertyPath>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitTargetPropertyPath(Local<Object> exports) {
    TargetPropertyPath::Init(exports);
  }

  class TemplatePartAttribute : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("TemplatePartAttribute").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("typeId").ToLocalChecked(), TypeIdGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("TemplatePartAttribute").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      TemplatePartAttribute(::Windows::UI::Xaml::TemplatePartAttribute^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::TemplatePartAttribute^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TemplatePartAttribute^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::TemplatePartAttribute^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::TemplatePartAttribute();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      TemplatePartAttribute *wrapperInstance = new TemplatePartAttribute(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TemplatePartAttribute^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::TemplatePartAttribute^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::TemplatePartAttribute^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapTemplatePartAttribute(winRtInstance));
    }





    static void TypeIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Platform::Attribute^>(info.This())) {
        return;
      }

      Attribute *wrapper = Attribute::Unwrap<Attribute>(info.This());

      try  {
        ::Platform::Object^ result = wrapper->_instance->TypeId;
        info.GetReturnValue().Set(CreateOpaqueWrapper(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::TemplatePartAttribute^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapTemplatePartAttribute(::Windows::UI::Xaml::TemplatePartAttribute^ wintRtInstance);
      friend ::Windows::UI::Xaml::TemplatePartAttribute^ UnwrapTemplatePartAttribute(Local<Value> value);
  };

  Persistent<FunctionTemplate> TemplatePartAttribute::s_constructorTemplate;

  v8::Local<v8::Value> WrapTemplatePartAttribute(::Windows::UI::Xaml::TemplatePartAttribute^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(TemplatePartAttribute::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::TemplatePartAttribute^ UnwrapTemplatePartAttribute(Local<Value> value) {
     return TemplatePartAttribute::Unwrap<TemplatePartAttribute>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitTemplatePartAttribute(Local<Object> exports) {
    TemplatePartAttribute::Init(exports);
  }

  class TemplateVisualStateAttribute : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("TemplateVisualStateAttribute").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("typeId").ToLocalChecked(), TypeIdGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("TemplateVisualStateAttribute").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      TemplateVisualStateAttribute(::Windows::UI::Xaml::TemplateVisualStateAttribute^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::TemplateVisualStateAttribute^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TemplateVisualStateAttribute^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::TemplateVisualStateAttribute^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::TemplateVisualStateAttribute();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      TemplateVisualStateAttribute *wrapperInstance = new TemplateVisualStateAttribute(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TemplateVisualStateAttribute^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::TemplateVisualStateAttribute^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::TemplateVisualStateAttribute^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapTemplateVisualStateAttribute(winRtInstance));
    }





    static void TypeIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Platform::Attribute^>(info.This())) {
        return;
      }

      Attribute *wrapper = Attribute::Unwrap<Attribute>(info.This());

      try  {
        ::Platform::Object^ result = wrapper->_instance->TypeId;
        info.GetReturnValue().Set(CreateOpaqueWrapper(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::TemplateVisualStateAttribute^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapTemplateVisualStateAttribute(::Windows::UI::Xaml::TemplateVisualStateAttribute^ wintRtInstance);
      friend ::Windows::UI::Xaml::TemplateVisualStateAttribute^ UnwrapTemplateVisualStateAttribute(Local<Value> value);
  };

  Persistent<FunctionTemplate> TemplateVisualStateAttribute::s_constructorTemplate;

  v8::Local<v8::Value> WrapTemplateVisualStateAttribute(::Windows::UI::Xaml::TemplateVisualStateAttribute^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(TemplateVisualStateAttribute::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::TemplateVisualStateAttribute^ UnwrapTemplateVisualStateAttribute(Local<Value> value) {
     return TemplateVisualStateAttribute::Unwrap<TemplateVisualStateAttribute>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitTemplateVisualStateAttribute(Local<Object> exports) {
    TemplateVisualStateAttribute::Init(exports);
  }

  class TriggerActionCollection : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("TriggerActionCollection").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "getAt", GetAt);
            Nan::SetPrototypeMethod(localRef, "getView", GetView);
            Nan::SetPrototypeMethod(localRef, "indexOf", IndexOf);
            Nan::SetPrototypeMethod(localRef, "setAt", SetAt);
            Nan::SetPrototypeMethod(localRef, "insertAt", InsertAt);
            Nan::SetPrototypeMethod(localRef, "removeAt", RemoveAt);
            Nan::SetPrototypeMethod(localRef, "append", Append);
            Nan::SetPrototypeMethod(localRef, "removeAtEnd", RemoveAtEnd);
            Nan::SetPrototypeMethod(localRef, "clear", Clear);
            Nan::SetPrototypeMethod(localRef, "getMany", GetMany);
            Nan::SetPrototypeMethod(localRef, "replaceAll", ReplaceAll);
            Nan::SetPrototypeMethod(localRef, "first", First);
          




        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("TriggerActionCollection").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      TriggerActionCollection(::Windows::UI::Xaml::TriggerActionCollection^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::TriggerActionCollection^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerActionCollection^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::TriggerActionCollection^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::TriggerActionCollection();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      TriggerActionCollection *wrapperInstance = new TriggerActionCollection(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerActionCollection^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::TriggerActionCollection^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::TriggerActionCollection^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapTriggerActionCollection(winRtInstance));
    }


    static void GetAt(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerActionCollection^>(info.This())) {
        return;
      }

      TriggerActionCollection *wrapper = TriggerActionCollection::Unwrap<TriggerActionCollection>(info.This());

      if (info.Length() == 1
        && info[0]->IsUint32())
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          
          ::Windows::UI::Xaml::TriggerAction^ result;
          result = wrapper->_instance->GetAt(arg0);
          info.GetReturnValue().Set(WrapTriggerAction(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetView(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerActionCollection^>(info.This())) {
        return;
      }

      TriggerActionCollection *wrapper = TriggerActionCollection::Unwrap<TriggerActionCollection>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Xaml::TriggerAction^>^ result;
          result = wrapper->_instance->GetView();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Xaml::TriggerAction^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Xaml::TriggerAction^ val) -> Local<Value> {
              return WrapTriggerAction(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerAction^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Xaml::TriggerAction^ {
              return UnwrapTriggerAction(value);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void IndexOf(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerActionCollection^>(info.This())) {
        return;
      }

      TriggerActionCollection *wrapper = TriggerActionCollection::Unwrap<TriggerActionCollection>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerAction^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::TriggerAction^ arg0 = UnwrapTriggerAction(info[0]);
          unsigned int arg1;
          
          bool result;
          result = wrapper->_instance->IndexOf(arg0, &arg1);
          Local<Object> resObj = Nan::New<Object>();
          Nan::Set(resObj, Nan::New<String>("boolean").ToLocalChecked(), Nan::New<Boolean>(result));
          Nan::Set(resObj, Nan::New<String>("index").ToLocalChecked(), Nan::New<Integer>(arg1));
          info.GetReturnValue().Set(resObj);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void SetAt(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerActionCollection^>(info.This())) {
        return;
      }

      TriggerActionCollection *wrapper = TriggerActionCollection::Unwrap<TriggerActionCollection>(info.This());

      if (info.Length() == 2
        && info[0]->IsUint32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerAction^>(info[1]))
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          ::Windows::UI::Xaml::TriggerAction^ arg1 = UnwrapTriggerAction(info[1]);
          
          wrapper->_instance->SetAt(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void InsertAt(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerActionCollection^>(info.This())) {
        return;
      }

      TriggerActionCollection *wrapper = TriggerActionCollection::Unwrap<TriggerActionCollection>(info.This());

      if (info.Length() == 2
        && info[0]->IsUint32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerAction^>(info[1]))
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          ::Windows::UI::Xaml::TriggerAction^ arg1 = UnwrapTriggerAction(info[1]);
          
          wrapper->_instance->InsertAt(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void RemoveAt(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerActionCollection^>(info.This())) {
        return;
      }

      TriggerActionCollection *wrapper = TriggerActionCollection::Unwrap<TriggerActionCollection>(info.This());

      if (info.Length() == 1
        && info[0]->IsUint32())
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          
          wrapper->_instance->RemoveAt(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Append(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerActionCollection^>(info.This())) {
        return;
      }

      TriggerActionCollection *wrapper = TriggerActionCollection::Unwrap<TriggerActionCollection>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerAction^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::TriggerAction^ arg0 = UnwrapTriggerAction(info[0]);
          
          wrapper->_instance->Append(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void RemoveAtEnd(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerActionCollection^>(info.This())) {
        return;
      }

      TriggerActionCollection *wrapper = TriggerActionCollection::Unwrap<TriggerActionCollection>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->RemoveAtEnd();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Clear(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerActionCollection^>(info.This())) {
        return;
      }

      TriggerActionCollection *wrapper = TriggerActionCollection::Unwrap<TriggerActionCollection>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->Clear();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetMany(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Not implemented")));
    }
    static void ReplaceAll(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerActionCollection^>(info.This())) {
        return;
      }

      TriggerActionCollection *wrapper = TriggerActionCollection::Unwrap<TriggerActionCollection>(info.This());

      if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<::Windows::UI::Xaml::TriggerAction^>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Platform::Array<::Windows::UI::Xaml::TriggerAction^>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<::Windows::UI::Xaml::TriggerAction^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<::Windows::UI::Xaml::TriggerAction^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerAction^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::UI::Xaml::TriggerAction^ {
                   return UnwrapTriggerAction(value);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<::Windows::UI::Xaml::TriggerAction^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          wrapper->_instance->ReplaceAll(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void First(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerActionCollection^>(info.This())) {
        return;
      }

      TriggerActionCollection *wrapper = TriggerActionCollection::Unwrap<TriggerActionCollection>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IIterator<::Windows::UI::Xaml::TriggerAction^>^ result;
          result = wrapper->_instance->First();
          info.GetReturnValue().Set(NodeRT::Collections::IteratorWrapper<::Windows::UI::Xaml::TriggerAction^>::CreateIteratorWrapper(result, 
            [](::Windows::UI::Xaml::TriggerAction^ val) -> Local<Value> {
              return WrapTriggerAction(val);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





    private:
      ::Windows::UI::Xaml::TriggerActionCollection^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapTriggerActionCollection(::Windows::UI::Xaml::TriggerActionCollection^ wintRtInstance);
      friend ::Windows::UI::Xaml::TriggerActionCollection^ UnwrapTriggerActionCollection(Local<Value> value);
  };

  Persistent<FunctionTemplate> TriggerActionCollection::s_constructorTemplate;

  v8::Local<v8::Value> WrapTriggerActionCollection(::Windows::UI::Xaml::TriggerActionCollection^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(TriggerActionCollection::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::TriggerActionCollection^ UnwrapTriggerActionCollection(Local<Value> value) {
     return TriggerActionCollection::Unwrap<TriggerActionCollection>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitTriggerActionCollection(Local<Object> exports) {
    TriggerActionCollection::Init(exports);
  }

  class TriggerCollection : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("TriggerCollection").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "getAt", GetAt);
            Nan::SetPrototypeMethod(localRef, "getView", GetView);
            Nan::SetPrototypeMethod(localRef, "indexOf", IndexOf);
            Nan::SetPrototypeMethod(localRef, "setAt", SetAt);
            Nan::SetPrototypeMethod(localRef, "insertAt", InsertAt);
            Nan::SetPrototypeMethod(localRef, "removeAt", RemoveAt);
            Nan::SetPrototypeMethod(localRef, "append", Append);
            Nan::SetPrototypeMethod(localRef, "removeAtEnd", RemoveAtEnd);
            Nan::SetPrototypeMethod(localRef, "clear", Clear);
            Nan::SetPrototypeMethod(localRef, "getMany", GetMany);
            Nan::SetPrototypeMethod(localRef, "replaceAll", ReplaceAll);
            Nan::SetPrototypeMethod(localRef, "first", First);
          




        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("TriggerCollection").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      TriggerCollection(::Windows::UI::Xaml::TriggerCollection^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::TriggerCollection^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerCollection^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::TriggerCollection^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      TriggerCollection *wrapperInstance = new TriggerCollection(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerCollection^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::TriggerCollection^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::TriggerCollection^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapTriggerCollection(winRtInstance));
    }


    static void GetAt(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerCollection^>(info.This())) {
        return;
      }

      TriggerCollection *wrapper = TriggerCollection::Unwrap<TriggerCollection>(info.This());

      if (info.Length() == 1
        && info[0]->IsUint32())
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          
          ::Windows::UI::Xaml::TriggerBase^ result;
          result = wrapper->_instance->GetAt(arg0);
          info.GetReturnValue().Set(WrapTriggerBase(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetView(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerCollection^>(info.This())) {
        return;
      }

      TriggerCollection *wrapper = TriggerCollection::Unwrap<TriggerCollection>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Xaml::TriggerBase^>^ result;
          result = wrapper->_instance->GetView();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Xaml::TriggerBase^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Xaml::TriggerBase^ val) -> Local<Value> {
              return WrapTriggerBase(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerBase^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Xaml::TriggerBase^ {
              return UnwrapTriggerBase(value);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void IndexOf(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerCollection^>(info.This())) {
        return;
      }

      TriggerCollection *wrapper = TriggerCollection::Unwrap<TriggerCollection>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerBase^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::TriggerBase^ arg0 = UnwrapTriggerBase(info[0]);
          unsigned int arg1;
          
          bool result;
          result = wrapper->_instance->IndexOf(arg0, &arg1);
          Local<Object> resObj = Nan::New<Object>();
          Nan::Set(resObj, Nan::New<String>("boolean").ToLocalChecked(), Nan::New<Boolean>(result));
          Nan::Set(resObj, Nan::New<String>("index").ToLocalChecked(), Nan::New<Integer>(arg1));
          info.GetReturnValue().Set(resObj);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void SetAt(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerCollection^>(info.This())) {
        return;
      }

      TriggerCollection *wrapper = TriggerCollection::Unwrap<TriggerCollection>(info.This());

      if (info.Length() == 2
        && info[0]->IsUint32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerBase^>(info[1]))
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          ::Windows::UI::Xaml::TriggerBase^ arg1 = UnwrapTriggerBase(info[1]);
          
          wrapper->_instance->SetAt(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void InsertAt(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerCollection^>(info.This())) {
        return;
      }

      TriggerCollection *wrapper = TriggerCollection::Unwrap<TriggerCollection>(info.This());

      if (info.Length() == 2
        && info[0]->IsUint32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerBase^>(info[1]))
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          ::Windows::UI::Xaml::TriggerBase^ arg1 = UnwrapTriggerBase(info[1]);
          
          wrapper->_instance->InsertAt(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void RemoveAt(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerCollection^>(info.This())) {
        return;
      }

      TriggerCollection *wrapper = TriggerCollection::Unwrap<TriggerCollection>(info.This());

      if (info.Length() == 1
        && info[0]->IsUint32())
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          
          wrapper->_instance->RemoveAt(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Append(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerCollection^>(info.This())) {
        return;
      }

      TriggerCollection *wrapper = TriggerCollection::Unwrap<TriggerCollection>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerBase^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::TriggerBase^ arg0 = UnwrapTriggerBase(info[0]);
          
          wrapper->_instance->Append(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void RemoveAtEnd(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerCollection^>(info.This())) {
        return;
      }

      TriggerCollection *wrapper = TriggerCollection::Unwrap<TriggerCollection>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->RemoveAtEnd();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Clear(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerCollection^>(info.This())) {
        return;
      }

      TriggerCollection *wrapper = TriggerCollection::Unwrap<TriggerCollection>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->Clear();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetMany(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Not implemented")));
    }
    static void ReplaceAll(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerCollection^>(info.This())) {
        return;
      }

      TriggerCollection *wrapper = TriggerCollection::Unwrap<TriggerCollection>(info.This());

      if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<::Windows::UI::Xaml::TriggerBase^>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Platform::Array<::Windows::UI::Xaml::TriggerBase^>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<::Windows::UI::Xaml::TriggerBase^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<::Windows::UI::Xaml::TriggerBase^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerBase^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::UI::Xaml::TriggerBase^ {
                   return UnwrapTriggerBase(value);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<::Windows::UI::Xaml::TriggerBase^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          wrapper->_instance->ReplaceAll(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void First(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::TriggerCollection^>(info.This())) {
        return;
      }

      TriggerCollection *wrapper = TriggerCollection::Unwrap<TriggerCollection>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IIterator<::Windows::UI::Xaml::TriggerBase^>^ result;
          result = wrapper->_instance->First();
          info.GetReturnValue().Set(NodeRT::Collections::IteratorWrapper<::Windows::UI::Xaml::TriggerBase^>::CreateIteratorWrapper(result, 
            [](::Windows::UI::Xaml::TriggerBase^ val) -> Local<Value> {
              return WrapTriggerBase(val);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





    private:
      ::Windows::UI::Xaml::TriggerCollection^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapTriggerCollection(::Windows::UI::Xaml::TriggerCollection^ wintRtInstance);
      friend ::Windows::UI::Xaml::TriggerCollection^ UnwrapTriggerCollection(Local<Value> value);
  };

  Persistent<FunctionTemplate> TriggerCollection::s_constructorTemplate;

  v8::Local<v8::Value> WrapTriggerCollection(::Windows::UI::Xaml::TriggerCollection^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(TriggerCollection::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::TriggerCollection^ UnwrapTriggerCollection(Local<Value> value) {
     return TriggerCollection::Unwrap<TriggerCollection>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitTriggerCollection(Local<Object> exports) {
    TriggerCollection::Init(exports);
  }

  class UIElementWeakCollection : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("UIElementWeakCollection").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "getAt", GetAt);
            Nan::SetPrototypeMethod(localRef, "getView", GetView);
            Nan::SetPrototypeMethod(localRef, "indexOf", IndexOf);
            Nan::SetPrototypeMethod(localRef, "setAt", SetAt);
            Nan::SetPrototypeMethod(localRef, "insertAt", InsertAt);
            Nan::SetPrototypeMethod(localRef, "removeAt", RemoveAt);
            Nan::SetPrototypeMethod(localRef, "append", Append);
            Nan::SetPrototypeMethod(localRef, "removeAtEnd", RemoveAtEnd);
            Nan::SetPrototypeMethod(localRef, "clear", Clear);
            Nan::SetPrototypeMethod(localRef, "getMany", GetMany);
            Nan::SetPrototypeMethod(localRef, "replaceAll", ReplaceAll);
            Nan::SetPrototypeMethod(localRef, "first", First);
          




        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("UIElementWeakCollection").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      UIElementWeakCollection(::Windows::UI::Xaml::UIElementWeakCollection^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::UIElementWeakCollection^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElementWeakCollection^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::UIElementWeakCollection^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::UIElementWeakCollection();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      UIElementWeakCollection *wrapperInstance = new UIElementWeakCollection(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElementWeakCollection^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::UIElementWeakCollection^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::UIElementWeakCollection^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapUIElementWeakCollection(winRtInstance));
    }


    static void GetAt(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElementWeakCollection^>(info.This())) {
        return;
      }

      UIElementWeakCollection *wrapper = UIElementWeakCollection::Unwrap<UIElementWeakCollection>(info.This());

      if (info.Length() == 1
        && info[0]->IsUint32())
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          
          ::Windows::UI::Xaml::UIElement^ result;
          result = wrapper->_instance->GetAt(arg0);
          info.GetReturnValue().Set(WrapUIElement(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetView(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElementWeakCollection^>(info.This())) {
        return;
      }

      UIElementWeakCollection *wrapper = UIElementWeakCollection::Unwrap<UIElementWeakCollection>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Xaml::UIElement^>^ result;
          result = wrapper->_instance->GetView();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Xaml::UIElement^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Xaml::UIElement^ val) -> Local<Value> {
              return WrapUIElement(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Xaml::UIElement^ {
              return UnwrapUIElement(value);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void IndexOf(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElementWeakCollection^>(info.This())) {
        return;
      }

      UIElementWeakCollection *wrapper = UIElementWeakCollection::Unwrap<UIElementWeakCollection>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::UIElement^ arg0 = UnwrapUIElement(info[0]);
          unsigned int arg1;
          
          bool result;
          result = wrapper->_instance->IndexOf(arg0, &arg1);
          Local<Object> resObj = Nan::New<Object>();
          Nan::Set(resObj, Nan::New<String>("boolean").ToLocalChecked(), Nan::New<Boolean>(result));
          Nan::Set(resObj, Nan::New<String>("index").ToLocalChecked(), Nan::New<Integer>(arg1));
          info.GetReturnValue().Set(resObj);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void SetAt(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElementWeakCollection^>(info.This())) {
        return;
      }

      UIElementWeakCollection *wrapper = UIElementWeakCollection::Unwrap<UIElementWeakCollection>(info.This());

      if (info.Length() == 2
        && info[0]->IsUint32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info[1]))
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          ::Windows::UI::Xaml::UIElement^ arg1 = UnwrapUIElement(info[1]);
          
          wrapper->_instance->SetAt(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void InsertAt(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElementWeakCollection^>(info.This())) {
        return;
      }

      UIElementWeakCollection *wrapper = UIElementWeakCollection::Unwrap<UIElementWeakCollection>(info.This());

      if (info.Length() == 2
        && info[0]->IsUint32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info[1]))
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          ::Windows::UI::Xaml::UIElement^ arg1 = UnwrapUIElement(info[1]);
          
          wrapper->_instance->InsertAt(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void RemoveAt(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElementWeakCollection^>(info.This())) {
        return;
      }

      UIElementWeakCollection *wrapper = UIElementWeakCollection::Unwrap<UIElementWeakCollection>(info.This());

      if (info.Length() == 1
        && info[0]->IsUint32())
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          
          wrapper->_instance->RemoveAt(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Append(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElementWeakCollection^>(info.This())) {
        return;
      }

      UIElementWeakCollection *wrapper = UIElementWeakCollection::Unwrap<UIElementWeakCollection>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::UIElement^ arg0 = UnwrapUIElement(info[0]);
          
          wrapper->_instance->Append(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void RemoveAtEnd(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElementWeakCollection^>(info.This())) {
        return;
      }

      UIElementWeakCollection *wrapper = UIElementWeakCollection::Unwrap<UIElementWeakCollection>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->RemoveAtEnd();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Clear(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElementWeakCollection^>(info.This())) {
        return;
      }

      UIElementWeakCollection *wrapper = UIElementWeakCollection::Unwrap<UIElementWeakCollection>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->Clear();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetMany(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Not implemented")));
    }
    static void ReplaceAll(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElementWeakCollection^>(info.This())) {
        return;
      }

      UIElementWeakCollection *wrapper = UIElementWeakCollection::Unwrap<UIElementWeakCollection>(info.This());

      if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<::Windows::UI::Xaml::UIElement^>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Platform::Array<::Windows::UI::Xaml::UIElement^>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<::Windows::UI::Xaml::UIElement^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<::Windows::UI::Xaml::UIElement^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::UI::Xaml::UIElement^ {
                   return UnwrapUIElement(value);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<::Windows::UI::Xaml::UIElement^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          wrapper->_instance->ReplaceAll(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void First(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElementWeakCollection^>(info.This())) {
        return;
      }

      UIElementWeakCollection *wrapper = UIElementWeakCollection::Unwrap<UIElementWeakCollection>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IIterator<::Windows::UI::Xaml::UIElement^>^ result;
          result = wrapper->_instance->First();
          info.GetReturnValue().Set(NodeRT::Collections::IteratorWrapper<::Windows::UI::Xaml::UIElement^>::CreateIteratorWrapper(result, 
            [](::Windows::UI::Xaml::UIElement^ val) -> Local<Value> {
              return WrapUIElement(val);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





    private:
      ::Windows::UI::Xaml::UIElementWeakCollection^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapUIElementWeakCollection(::Windows::UI::Xaml::UIElementWeakCollection^ wintRtInstance);
      friend ::Windows::UI::Xaml::UIElementWeakCollection^ UnwrapUIElementWeakCollection(Local<Value> value);
  };

  Persistent<FunctionTemplate> UIElementWeakCollection::s_constructorTemplate;

  v8::Local<v8::Value> WrapUIElementWeakCollection(::Windows::UI::Xaml::UIElementWeakCollection^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(UIElementWeakCollection::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::UIElementWeakCollection^ UnwrapUIElementWeakCollection(Local<Value> value) {
     return UIElementWeakCollection::Unwrap<UIElementWeakCollection>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitUIElementWeakCollection(Local<Object> exports) {
    UIElementWeakCollection::Init(exports);
  }

  class UnhandledExceptionEventArgs : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("UnhandledExceptionEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("handled").ToLocalChecked(), HandledGetter, HandledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("exception").ToLocalChecked(), ExceptionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("message").ToLocalChecked(), MessageGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("UnhandledExceptionEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      UnhandledExceptionEventArgs(::Windows::UI::Xaml::UnhandledExceptionEventArgs^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::UnhandledExceptionEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UnhandledExceptionEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::UnhandledExceptionEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      UnhandledExceptionEventArgs *wrapperInstance = new UnhandledExceptionEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UnhandledExceptionEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::UnhandledExceptionEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::UnhandledExceptionEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapUnhandledExceptionEventArgs(winRtInstance));
    }





    static void HandledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UnhandledExceptionEventArgs^>(info.This())) {
        return;
      }

      UnhandledExceptionEventArgs *wrapper = UnhandledExceptionEventArgs::Unwrap<UnhandledExceptionEventArgs>(info.This());

      try  {
        bool result = wrapper->_instance->Handled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void HandledSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UnhandledExceptionEventArgs^>(info.This())) {
        return;
      }

      UnhandledExceptionEventArgs *wrapper = UnhandledExceptionEventArgs::Unwrap<UnhandledExceptionEventArgs>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->Handled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ExceptionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UnhandledExceptionEventArgs^>(info.This())) {
        return;
      }

      UnhandledExceptionEventArgs *wrapper = UnhandledExceptionEventArgs::Unwrap<UnhandledExceptionEventArgs>(info.This());

      try  {
        ::Windows::Foundation::HResult result = wrapper->_instance->Exception;
        info.GetReturnValue().Set(Nan::New<Integer>(result.Value));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MessageGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UnhandledExceptionEventArgs^>(info.This())) {
        return;
      }

      UnhandledExceptionEventArgs *wrapper = UnhandledExceptionEventArgs::Unwrap<UnhandledExceptionEventArgs>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Message;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::UnhandledExceptionEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapUnhandledExceptionEventArgs(::Windows::UI::Xaml::UnhandledExceptionEventArgs^ wintRtInstance);
      friend ::Windows::UI::Xaml::UnhandledExceptionEventArgs^ UnwrapUnhandledExceptionEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> UnhandledExceptionEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapUnhandledExceptionEventArgs(::Windows::UI::Xaml::UnhandledExceptionEventArgs^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(UnhandledExceptionEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::UnhandledExceptionEventArgs^ UnwrapUnhandledExceptionEventArgs(Local<Value> value) {
     return UnhandledExceptionEventArgs::Unwrap<UnhandledExceptionEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitUnhandledExceptionEventArgs(Local<Object> exports) {
    UnhandledExceptionEventArgs::Init(exports);
  }

  class Vector3Transition : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("Vector3Transition").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("duration").ToLocalChecked(), DurationGetter, DurationSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("components").ToLocalChecked(), ComponentsGetter, ComponentsSetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("Vector3Transition").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      Vector3Transition(::Windows::UI::Xaml::Vector3Transition^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::Vector3Transition^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Vector3Transition^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::Vector3Transition^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::Vector3Transition();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      Vector3Transition *wrapperInstance = new Vector3Transition(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Vector3Transition^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::Vector3Transition^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::Vector3Transition^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapVector3Transition(winRtInstance));
    }





    static void DurationGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Vector3Transition^>(info.This())) {
        return;
      }

      Vector3Transition *wrapper = Vector3Transition::Unwrap<Vector3Transition>(info.This());

      try  {
        ::Windows::Foundation::TimeSpan result = wrapper->_instance->Duration;
        info.GetReturnValue().Set(Nan::New<Number>(result.Duration/10000.0));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DurationSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Vector3Transition^>(info.This())) {
        return;
      }

      Vector3Transition *wrapper = Vector3Transition::Unwrap<Vector3Transition>(info.This());

      try {

        ::Windows::Foundation::TimeSpan winRtValue = NodeRT::Utils::TimeSpanFromMilli(Nan::To<int64_t>(value).FromMaybe(0));

        wrapper->_instance->Duration = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ComponentsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Vector3Transition^>(info.This())) {
        return;
      }

      Vector3Transition *wrapper = Vector3Transition::Unwrap<Vector3Transition>(info.This());

      try  {
        ::Windows::UI::Xaml::Vector3TransitionComponents result = wrapper->_instance->Components;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ComponentsSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Vector3Transition^>(info.This())) {
        return;
      }

      Vector3Transition *wrapper = Vector3Transition::Unwrap<Vector3Transition>(info.This());

      try {

        ::Windows::UI::Xaml::Vector3TransitionComponents winRtValue = static_cast<::Windows::UI::Xaml::Vector3TransitionComponents>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->Components = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      


    private:
      ::Windows::UI::Xaml::Vector3Transition^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVector3Transition(::Windows::UI::Xaml::Vector3Transition^ wintRtInstance);
      friend ::Windows::UI::Xaml::Vector3Transition^ UnwrapVector3Transition(Local<Value> value);
  };

  Persistent<FunctionTemplate> Vector3Transition::s_constructorTemplate;

  v8::Local<v8::Value> WrapVector3Transition(::Windows::UI::Xaml::Vector3Transition^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(Vector3Transition::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::Vector3Transition^ UnwrapVector3Transition(Local<Value> value) {
     return Vector3Transition::Unwrap<Vector3Transition>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVector3Transition(Local<Object> exports) {
    Vector3Transition::Init(exports);
  }

  class VisualState : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("VisualState").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("storyboard").ToLocalChecked(), StoryboardGetter, StoryboardSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("name").ToLocalChecked(), NameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("setters").ToLocalChecked(), SettersGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("stateTriggers").ToLocalChecked(), StateTriggersGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("VisualState").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      VisualState(::Windows::UI::Xaml::VisualState^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::VisualState^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualState^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::VisualState^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::VisualState();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      VisualState *wrapperInstance = new VisualState(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualState^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::VisualState^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::VisualState^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapVisualState(winRtInstance));
    }





    static void StoryboardGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualState^>(info.This())) {
        return;
      }

      VisualState *wrapper = VisualState::Unwrap<VisualState>(info.This());

      try  {
        ::Windows::UI::Xaml::Media::Animation::Storyboard^ result = wrapper->_instance->Storyboard;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Media.Animation", "Storyboard", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void StoryboardSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Media::Animation::Storyboard^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualState^>(info.This())) {
        return;
      }

      VisualState *wrapper = VisualState::Unwrap<VisualState>(info.This());

      try {

        ::Windows::UI::Xaml::Media::Animation::Storyboard^ winRtValue = dynamic_cast<::Windows::UI::Xaml::Media::Animation::Storyboard^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Storyboard = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void NameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualState^>(info.This())) {
        return;
      }

      VisualState *wrapper = VisualState::Unwrap<VisualState>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Name;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SettersGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualState^>(info.This())) {
        return;
      }

      VisualState *wrapper = VisualState::Unwrap<VisualState>(info.This());

      try  {
        ::Windows::UI::Xaml::SetterBaseCollection^ result = wrapper->_instance->Setters;
        info.GetReturnValue().Set(WrapSetterBaseCollection(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void StateTriggersGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualState^>(info.This())) {
        return;
      }

      VisualState *wrapper = VisualState::Unwrap<VisualState>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::UI::Xaml::StateTriggerBase^>^ result = wrapper->_instance->StateTriggers;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::UI::Xaml::StateTriggerBase^>::CreateVectorWrapper(result, 
            [](::Windows::UI::Xaml::StateTriggerBase^ val) -> Local<Value> {
              return WrapStateTriggerBase(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::StateTriggerBase^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Xaml::StateTriggerBase^ {
              return UnwrapStateTriggerBase(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DispatcherGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      try  {
        ::Windows::UI::Core::CoreDispatcher^ result = wrapper->_instance->Dispatcher;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "CoreDispatcher", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::VisualState^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVisualState(::Windows::UI::Xaml::VisualState^ wintRtInstance);
      friend ::Windows::UI::Xaml::VisualState^ UnwrapVisualState(Local<Value> value);
  };

  Persistent<FunctionTemplate> VisualState::s_constructorTemplate;

  v8::Local<v8::Value> WrapVisualState(::Windows::UI::Xaml::VisualState^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(VisualState::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::VisualState^ UnwrapVisualState(Local<Value> value) {
     return VisualState::Unwrap<VisualState>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVisualState(Local<Object> exports) {
    VisualState::Init(exports);
  }

  class VisualStateChangedEventArgs : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("VisualStateChangedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("oldState").ToLocalChecked(), OldStateGetter, OldStateSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("newState").ToLocalChecked(), NewStateGetter, NewStateSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("control").ToLocalChecked(), ControlGetter, ControlSetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("VisualStateChangedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      VisualStateChangedEventArgs(::Windows::UI::Xaml::VisualStateChangedEventArgs^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::VisualStateChangedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualStateChangedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::VisualStateChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::VisualStateChangedEventArgs();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      VisualStateChangedEventArgs *wrapperInstance = new VisualStateChangedEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualStateChangedEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::VisualStateChangedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::VisualStateChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapVisualStateChangedEventArgs(winRtInstance));
    }





    static void OldStateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualStateChangedEventArgs^>(info.This())) {
        return;
      }

      VisualStateChangedEventArgs *wrapper = VisualStateChangedEventArgs::Unwrap<VisualStateChangedEventArgs>(info.This());

      try  {
        ::Windows::UI::Xaml::VisualState^ result = wrapper->_instance->OldState;
        info.GetReturnValue().Set(WrapVisualState(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void OldStateSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualState^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualStateChangedEventArgs^>(info.This())) {
        return;
      }

      VisualStateChangedEventArgs *wrapper = VisualStateChangedEventArgs::Unwrap<VisualStateChangedEventArgs>(info.This());

      try {

        ::Windows::UI::Xaml::VisualState^ winRtValue = dynamic_cast<::Windows::UI::Xaml::VisualState^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->OldState = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void NewStateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualStateChangedEventArgs^>(info.This())) {
        return;
      }

      VisualStateChangedEventArgs *wrapper = VisualStateChangedEventArgs::Unwrap<VisualStateChangedEventArgs>(info.This());

      try  {
        ::Windows::UI::Xaml::VisualState^ result = wrapper->_instance->NewState;
        info.GetReturnValue().Set(WrapVisualState(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void NewStateSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualState^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualStateChangedEventArgs^>(info.This())) {
        return;
      }

      VisualStateChangedEventArgs *wrapper = VisualStateChangedEventArgs::Unwrap<VisualStateChangedEventArgs>(info.This());

      try {

        ::Windows::UI::Xaml::VisualState^ winRtValue = dynamic_cast<::Windows::UI::Xaml::VisualState^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->NewState = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ControlGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualStateChangedEventArgs^>(info.This())) {
        return;
      }

      VisualStateChangedEventArgs *wrapper = VisualStateChangedEventArgs::Unwrap<VisualStateChangedEventArgs>(info.This());

      try  {
        ::Windows::UI::Xaml::Controls::Control^ result = wrapper->_instance->Control;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Controls", "Control", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ControlSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Controls::Control^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualStateChangedEventArgs^>(info.This())) {
        return;
      }

      VisualStateChangedEventArgs *wrapper = VisualStateChangedEventArgs::Unwrap<VisualStateChangedEventArgs>(info.This());

      try {

        ::Windows::UI::Xaml::Controls::Control^ winRtValue = dynamic_cast<::Windows::UI::Xaml::Controls::Control^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Control = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      


    private:
      ::Windows::UI::Xaml::VisualStateChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVisualStateChangedEventArgs(::Windows::UI::Xaml::VisualStateChangedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Xaml::VisualStateChangedEventArgs^ UnwrapVisualStateChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> VisualStateChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapVisualStateChangedEventArgs(::Windows::UI::Xaml::VisualStateChangedEventArgs^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(VisualStateChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::VisualStateChangedEventArgs^ UnwrapVisualStateChangedEventArgs(Local<Value> value) {
     return VisualStateChangedEventArgs::Unwrap<VisualStateChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVisualStateChangedEventArgs(Local<Object> exports) {
    VisualStateChangedEventArgs::Init(exports);
  }

  class VisualStateGroup : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("VisualStateGroup").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);




          
          Nan::SetPrototypeMethod(localRef,"addListener", AddListener);
          Nan::SetPrototypeMethod(localRef,"on", AddListener);
          Nan::SetPrototypeMethod(localRef,"removeListener", RemoveListener);
          Nan::SetPrototypeMethod(localRef, "off", RemoveListener);

          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("currentState").ToLocalChecked(), CurrentStateGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("name").ToLocalChecked(), NameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("states").ToLocalChecked(), StatesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("transitions").ToLocalChecked(), TransitionsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("VisualStateGroup").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      VisualStateGroup(::Windows::UI::Xaml::VisualStateGroup^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::VisualStateGroup^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualStateGroup^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::VisualStateGroup^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::VisualStateGroup();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      VisualStateGroup *wrapperInstance = new VisualStateGroup(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualStateGroup^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::VisualStateGroup^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::VisualStateGroup^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapVisualStateGroup(winRtInstance));
    }





    static void CurrentStateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualStateGroup^>(info.This())) {
        return;
      }

      VisualStateGroup *wrapper = VisualStateGroup::Unwrap<VisualStateGroup>(info.This());

      try  {
        ::Windows::UI::Xaml::VisualState^ result = wrapper->_instance->CurrentState;
        info.GetReturnValue().Set(WrapVisualState(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void NameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualStateGroup^>(info.This())) {
        return;
      }

      VisualStateGroup *wrapper = VisualStateGroup::Unwrap<VisualStateGroup>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Name;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void StatesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualStateGroup^>(info.This())) {
        return;
      }

      VisualStateGroup *wrapper = VisualStateGroup::Unwrap<VisualStateGroup>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::UI::Xaml::VisualState^>^ result = wrapper->_instance->States;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::UI::Xaml::VisualState^>::CreateVectorWrapper(result, 
            [](::Windows::UI::Xaml::VisualState^ val) -> Local<Value> {
              return WrapVisualState(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualState^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Xaml::VisualState^ {
              return UnwrapVisualState(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TransitionsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualStateGroup^>(info.This())) {
        return;
      }

      VisualStateGroup *wrapper = VisualStateGroup::Unwrap<VisualStateGroup>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::UI::Xaml::VisualTransition^>^ result = wrapper->_instance->Transitions;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::UI::Xaml::VisualTransition^>::CreateVectorWrapper(result, 
            [](::Windows::UI::Xaml::VisualTransition^ val) -> Local<Value> {
              return WrapVisualTransition(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualTransition^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Xaml::VisualTransition^ {
              return UnwrapVisualTransition(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DispatcherGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      try  {
        ::Windows::UI::Core::CoreDispatcher^ result = wrapper->_instance->Dispatcher;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "CoreDispatcher", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    static void AddListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"currentStateChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualStateGroup^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        VisualStateGroup *wrapper = VisualStateGroup::Unwrap<VisualStateGroup>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->CurrentStateChanged::add(
            ref new ::Windows::UI::Xaml::VisualStateChangedEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::VisualStateChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = WrapVisualStateChangedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"currentStateChanging", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualStateGroup^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        VisualStateGroup *wrapper = VisualStateGroup::Unwrap<VisualStateGroup>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->CurrentStateChanging::add(
            ref new ::Windows::UI::Xaml::VisualStateChangedEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Xaml::VisualStateChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = WrapVisualStateChangedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
 else  {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Value> tokenMapVal = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());
      Local<Object> tokenMap;

      if (tokenMapVal.IsEmpty() || Nan::Equals(tokenMapVal, Undefined()).FromMaybe(false)) {
        tokenMap = Nan::New<Object>();
        NodeRT::Utils::SetHiddenValueWithObject(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked(), tokenMap);
      } else {
        tokenMap = Nan::To<Object>(tokenMapVal).ToLocalChecked();
      }

      Nan::Set(tokenMap, info[0], CreateOpaqueWrapper(::Windows::Foundation::PropertyValue::CreateInt64(registrationToken.Value)));
    }

    static void RemoveListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected a string and a callback")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      if ((!NodeRT::Utils::CaseInsenstiveEquals(L"currentStateChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"currentStateChanging", str))) {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Function> callback = info[1].As<Function>();
      Local<Value> tokenMap = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());

      if (tokenMap.IsEmpty() || Nan::Equals(tokenMap, Undefined()).FromMaybe(false)) {
        return;
      }

      Local<Value> opaqueWrapperObj =  Nan::Get(Nan::To<Object>(tokenMap).ToLocalChecked(), info[0]).ToLocalChecked();

      if (opaqueWrapperObj.IsEmpty() || Nan::Equals(opaqueWrapperObj,Undefined()).FromMaybe(false)) {
        return;
      }

      OpaqueWrapper *opaqueWrapper = OpaqueWrapper::Unwrap<OpaqueWrapper>(opaqueWrapperObj.As<Object>());

      long long tokenValue = (long long) opaqueWrapper->GetObjectInstance();
      ::Windows::Foundation::EventRegistrationToken registrationToken;
      registrationToken.Value = tokenValue;

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"currentStateChanged", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualStateGroup^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          VisualStateGroup *wrapper = VisualStateGroup::Unwrap<VisualStateGroup>(info.This());
          wrapper->_instance->CurrentStateChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"currentStateChanging", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualStateGroup^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          VisualStateGroup *wrapper = VisualStateGroup::Unwrap<VisualStateGroup>(info.This());
          wrapper->_instance->CurrentStateChanging::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

      Nan::Delete(Nan::To<Object>(tokenMap).ToLocalChecked(), Nan::To<String>(info[0]).ToLocalChecked());
    }
    private:
      ::Windows::UI::Xaml::VisualStateGroup^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVisualStateGroup(::Windows::UI::Xaml::VisualStateGroup^ wintRtInstance);
      friend ::Windows::UI::Xaml::VisualStateGroup^ UnwrapVisualStateGroup(Local<Value> value);
  };

  Persistent<FunctionTemplate> VisualStateGroup::s_constructorTemplate;

  v8::Local<v8::Value> WrapVisualStateGroup(::Windows::UI::Xaml::VisualStateGroup^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(VisualStateGroup::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::VisualStateGroup^ UnwrapVisualStateGroup(Local<Value> value) {
     return VisualStateGroup::Unwrap<VisualStateGroup>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVisualStateGroup(Local<Object> exports) {
    VisualStateGroup::Init(exports);
  }

  class VisualStateManager : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("VisualStateManager").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "raiseCurrentStateChanging", RaiseCurrentStateChanging);
            Nan::SetPrototypeMethod(localRef, "raiseCurrentStateChanged", RaiseCurrentStateChanged);
            Nan::SetPrototypeMethod(localRef, "goToStateCore", GoToStateCore);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetMethod(constructor, "getVisualStateGroups", GetVisualStateGroups);
        Nan::SetMethod(constructor, "getCustomVisualStateManager", GetCustomVisualStateManager);
        Nan::SetMethod(constructor, "setCustomVisualStateManager", SetCustomVisualStateManager);
        Nan::SetMethod(constructor, "goToState", GoToState);
        Nan::SetAccessor(constructor, Nan::New<String>("customVisualStateManagerProperty").ToLocalChecked(), CustomVisualStateManagerPropertyGetter);


        Nan::Set(exports, Nan::New<String>("VisualStateManager").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      VisualStateManager(::Windows::UI::Xaml::VisualStateManager^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::VisualStateManager^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualStateManager^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::VisualStateManager^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::VisualStateManager();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      VisualStateManager *wrapperInstance = new VisualStateManager(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualStateManager^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::VisualStateManager^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::VisualStateManager^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapVisualStateManager(winRtInstance));
    }


    static void RaiseCurrentStateChanging(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualStateManager^>(info.This())) {
        return;
      }

      VisualStateManager *wrapper = VisualStateManager::Unwrap<VisualStateManager>(info.This());

      if (info.Length() == 4
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualStateGroup^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualState^>(info[1])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualState^>(info[2])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Controls::Control^>(info[3]))
      {
        try
        {
          ::Windows::UI::Xaml::VisualStateGroup^ arg0 = UnwrapVisualStateGroup(info[0]);
          ::Windows::UI::Xaml::VisualState^ arg1 = UnwrapVisualState(info[1]);
          ::Windows::UI::Xaml::VisualState^ arg2 = UnwrapVisualState(info[2]);
          ::Windows::UI::Xaml::Controls::Control^ arg3 = dynamic_cast<::Windows::UI::Xaml::Controls::Control^>(NodeRT::Utils::GetObjectInstance(info[3]));
          
          wrapper->_instance->RaiseCurrentStateChanging(arg0, arg1, arg2, arg3);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void RaiseCurrentStateChanged(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualStateManager^>(info.This())) {
        return;
      }

      VisualStateManager *wrapper = VisualStateManager::Unwrap<VisualStateManager>(info.This());

      if (info.Length() == 4
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualStateGroup^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualState^>(info[1])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualState^>(info[2])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Controls::Control^>(info[3]))
      {
        try
        {
          ::Windows::UI::Xaml::VisualStateGroup^ arg0 = UnwrapVisualStateGroup(info[0]);
          ::Windows::UI::Xaml::VisualState^ arg1 = UnwrapVisualState(info[1]);
          ::Windows::UI::Xaml::VisualState^ arg2 = UnwrapVisualState(info[2]);
          ::Windows::UI::Xaml::Controls::Control^ arg3 = dynamic_cast<::Windows::UI::Xaml::Controls::Control^>(NodeRT::Utils::GetObjectInstance(info[3]));
          
          wrapper->_instance->RaiseCurrentStateChanged(arg0, arg1, arg2, arg3);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GoToStateCore(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualStateManager^>(info.This())) {
        return;
      }

      VisualStateManager *wrapper = VisualStateManager::Unwrap<VisualStateManager>(info.This());

      if (info.Length() == 6
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Controls::Control^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info[1])
        && info[2]->IsString()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualStateGroup^>(info[3])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualState^>(info[4])
        && info[5]->IsBoolean())
      {
        try
        {
          ::Windows::UI::Xaml::Controls::Control^ arg0 = dynamic_cast<::Windows::UI::Xaml::Controls::Control^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::UI::Xaml::FrameworkElement^ arg1 = UnwrapFrameworkElement(info[1]);
          Platform::String^ arg2 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[2])));
          ::Windows::UI::Xaml::VisualStateGroup^ arg3 = UnwrapVisualStateGroup(info[3]);
          ::Windows::UI::Xaml::VisualState^ arg4 = UnwrapVisualState(info[4]);
          bool arg5 = Nan::To<bool>(info[5]).FromMaybe(false);
          
          bool result;
          result = wrapper->_instance->GoToStateCore(arg0, arg1, arg2, arg3, arg4, arg5);
          info.GetReturnValue().Set(Nan::New<Boolean>(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    static void GetVisualStateGroups(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::FrameworkElement^ arg0 = UnwrapFrameworkElement(info[0]);
          
          ::Windows::Foundation::Collections::IVector<::Windows::UI::Xaml::VisualStateGroup^>^ result;
          result = ::Windows::UI::Xaml::VisualStateManager::GetVisualStateGroups(arg0);
          info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::UI::Xaml::VisualStateGroup^>::CreateVectorWrapper(result, 
            [](::Windows::UI::Xaml::VisualStateGroup^ val) -> Local<Value> {
              return WrapVisualStateGroup(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualStateGroup^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Xaml::VisualStateGroup^ {
              return UnwrapVisualStateGroup(value);
            }
          ));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void GetCustomVisualStateManager(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::FrameworkElement^ arg0 = UnwrapFrameworkElement(info[0]);
          
          ::Windows::UI::Xaml::VisualStateManager^ result;
          result = ::Windows::UI::Xaml::VisualStateManager::GetCustomVisualStateManager(arg0);
          info.GetReturnValue().Set(WrapVisualStateManager(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void SetCustomVisualStateManager(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::FrameworkElement^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualStateManager^>(info[1]))
      {
        try
        {
          ::Windows::UI::Xaml::FrameworkElement^ arg0 = UnwrapFrameworkElement(info[0]);
          ::Windows::UI::Xaml::VisualStateManager^ arg1 = UnwrapVisualStateManager(info[1]);
          
          ::Windows::UI::Xaml::VisualStateManager::SetCustomVisualStateManager(arg0, arg1);
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void GoToState(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Controls::Control^>(info[0])
        && info[1]->IsString()
        && info[2]->IsBoolean())
      {
        try
        {
          ::Windows::UI::Xaml::Controls::Control^ arg0 = dynamic_cast<::Windows::UI::Xaml::Controls::Control^>(NodeRT::Utils::GetObjectInstance(info[0]));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          bool arg2 = Nan::To<bool>(info[2]).FromMaybe(false);
          
          bool result;
          result = ::Windows::UI::Xaml::VisualStateManager::GoToState(arg0, arg1, arg2);
          info.GetReturnValue().Set(Nan::New<Boolean>(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void DispatcherGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      try  {
        ::Windows::UI::Core::CoreDispatcher^ result = wrapper->_instance->Dispatcher;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "CoreDispatcher", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    static void CustomVisualStateManagerPropertyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::DependencyProperty^ result = ::Windows::UI::Xaml::VisualStateManager::CustomVisualStateManagerProperty;
        info.GetReturnValue().Set(WrapDependencyProperty(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    private:
      ::Windows::UI::Xaml::VisualStateManager^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVisualStateManager(::Windows::UI::Xaml::VisualStateManager^ wintRtInstance);
      friend ::Windows::UI::Xaml::VisualStateManager^ UnwrapVisualStateManager(Local<Value> value);
  };

  Persistent<FunctionTemplate> VisualStateManager::s_constructorTemplate;

  v8::Local<v8::Value> WrapVisualStateManager(::Windows::UI::Xaml::VisualStateManager^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(VisualStateManager::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::VisualStateManager^ UnwrapVisualStateManager(Local<Value> value) {
     return VisualStateManager::Unwrap<VisualStateManager>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVisualStateManager(Local<Object> exports) {
    VisualStateManager::Init(exports);
  }

  class VisualTransition : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("VisualTransition").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("to").ToLocalChecked(), ToGetter, ToSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("storyboard").ToLocalChecked(), StoryboardGetter, StoryboardSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("generatedEasingFunction").ToLocalChecked(), GeneratedEasingFunctionGetter, GeneratedEasingFunctionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("generatedDuration").ToLocalChecked(), GeneratedDurationGetter, GeneratedDurationSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("from").ToLocalChecked(), FromGetter, FromSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("VisualTransition").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      VisualTransition(::Windows::UI::Xaml::VisualTransition^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::VisualTransition^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualTransition^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::VisualTransition^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Xaml::VisualTransition();
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      VisualTransition *wrapperInstance = new VisualTransition(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualTransition^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::VisualTransition^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::VisualTransition^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapVisualTransition(winRtInstance));
    }





    static void ToGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualTransition^>(info.This())) {
        return;
      }

      VisualTransition *wrapper = VisualTransition::Unwrap<VisualTransition>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->To;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ToSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsString()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualTransition^>(info.This())) {
        return;
      }

      VisualTransition *wrapper = VisualTransition::Unwrap<VisualTransition>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->To = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void StoryboardGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualTransition^>(info.This())) {
        return;
      }

      VisualTransition *wrapper = VisualTransition::Unwrap<VisualTransition>(info.This());

      try  {
        ::Windows::UI::Xaml::Media::Animation::Storyboard^ result = wrapper->_instance->Storyboard;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Media.Animation", "Storyboard", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void StoryboardSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Media::Animation::Storyboard^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualTransition^>(info.This())) {
        return;
      }

      VisualTransition *wrapper = VisualTransition::Unwrap<VisualTransition>(info.This());

      try {

        ::Windows::UI::Xaml::Media::Animation::Storyboard^ winRtValue = dynamic_cast<::Windows::UI::Xaml::Media::Animation::Storyboard^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Storyboard = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void GeneratedEasingFunctionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualTransition^>(info.This())) {
        return;
      }

      VisualTransition *wrapper = VisualTransition::Unwrap<VisualTransition>(info.This());

      try  {
        ::Windows::UI::Xaml::Media::Animation::EasingFunctionBase^ result = wrapper->_instance->GeneratedEasingFunction;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Xaml.Media.Animation", "EasingFunctionBase", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void GeneratedEasingFunctionSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Media::Animation::EasingFunctionBase^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualTransition^>(info.This())) {
        return;
      }

      VisualTransition *wrapper = VisualTransition::Unwrap<VisualTransition>(info.This());

      try {

        ::Windows::UI::Xaml::Media::Animation::EasingFunctionBase^ winRtValue = dynamic_cast<::Windows::UI::Xaml::Media::Animation::EasingFunctionBase^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->GeneratedEasingFunction = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void GeneratedDurationGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualTransition^>(info.This())) {
        return;
      }

      VisualTransition *wrapper = VisualTransition::Unwrap<VisualTransition>(info.This());

      try  {
        ::Windows::UI::Xaml::Duration result = wrapper->_instance->GeneratedDuration;
        info.GetReturnValue().Set(DurationToJsObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void GeneratedDurationSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!IsDurationJsObject(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualTransition^>(info.This())) {
        return;
      }

      VisualTransition *wrapper = VisualTransition::Unwrap<VisualTransition>(info.This());

      try {

        ::Windows::UI::Xaml::Duration winRtValue = DurationFromJsObject(value);

        wrapper->_instance->GeneratedDuration = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void FromGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualTransition^>(info.This())) {
        return;
      }

      VisualTransition *wrapper = VisualTransition::Unwrap<VisualTransition>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->From;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void FromSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsString()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::VisualTransition^>(info.This())) {
        return;
      }

      VisualTransition *wrapper = VisualTransition::Unwrap<VisualTransition>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->From = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void DispatcherGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::DependencyObject^>(info.This())) {
        return;
      }

      DependencyObject *wrapper = DependencyObject::Unwrap<DependencyObject>(info.This());

      try  {
        ::Windows::UI::Core::CoreDispatcher^ result = wrapper->_instance->Dispatcher;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "CoreDispatcher", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::VisualTransition^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVisualTransition(::Windows::UI::Xaml::VisualTransition^ wintRtInstance);
      friend ::Windows::UI::Xaml::VisualTransition^ UnwrapVisualTransition(Local<Value> value);
  };

  Persistent<FunctionTemplate> VisualTransition::s_constructorTemplate;

  v8::Local<v8::Value> WrapVisualTransition(::Windows::UI::Xaml::VisualTransition^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(VisualTransition::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::VisualTransition^ UnwrapVisualTransition(Local<Value> value) {
     return VisualTransition::Unwrap<VisualTransition>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVisualTransition(Local<Object> exports) {
    VisualTransition::Init(exports);
  }

  class Window : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("Window").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "activate", Activate);
            Nan::SetPrototypeMethod(localRef, "close", Close);
            Nan::SetPrototypeMethod(localRef, "setTitleBar", SetTitleBar);
          


          
          Nan::SetPrototypeMethod(localRef,"addListener", AddListener);
          Nan::SetPrototypeMethod(localRef,"on", AddListener);
          Nan::SetPrototypeMethod(localRef,"removeListener", RemoveListener);
          Nan::SetPrototypeMethod(localRef, "off", RemoveListener);

          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("content").ToLocalChecked(), ContentGetter, ContentSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("bounds").ToLocalChecked(), BoundsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("coreWindow").ToLocalChecked(), CoreWindowGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("visible").ToLocalChecked(), VisibleGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("compositor").ToLocalChecked(), CompositorGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("uIContext").ToLocalChecked(), UIContextGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetAccessor(constructor, Nan::New<String>("current").ToLocalChecked(), CurrentGetter);


        Nan::Set(exports, Nan::New<String>("Window").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      Window(::Windows::UI::Xaml::Window^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::Window^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Window^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::Window^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      Window *wrapperInstance = new Window(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Window^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::Window^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::Window^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapWindow(winRtInstance));
    }


    static void Activate(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Window^>(info.This())) {
        return;
      }

      Window *wrapper = Window::Unwrap<Window>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->Activate();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Close(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Window^>(info.This())) {
        return;
      }

      Window *wrapper = Window::Unwrap<Window>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->Close();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void SetTitleBar(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Window^>(info.This())) {
        return;
      }

      Window *wrapper = Window::Unwrap<Window>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::UIElement^ arg0 = UnwrapUIElement(info[0]);
          
          wrapper->_instance->SetTitleBar(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    static void ContentGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Window^>(info.This())) {
        return;
      }

      Window *wrapper = Window::Unwrap<Window>(info.This());

      try  {
        ::Windows::UI::Xaml::UIElement^ result = wrapper->_instance->Content;
        info.GetReturnValue().Set(WrapUIElement(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ContentSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::UIElement^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Window^>(info.This())) {
        return;
      }

      Window *wrapper = Window::Unwrap<Window>(info.This());

      try {

        ::Windows::UI::Xaml::UIElement^ winRtValue = dynamic_cast<::Windows::UI::Xaml::UIElement^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Content = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void BoundsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Window^>(info.This())) {
        return;
      }

      Window *wrapper = Window::Unwrap<Window>(info.This());

      try  {
        ::Windows::Foundation::Rect result = wrapper->_instance->Bounds;
        info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CoreWindowGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Window^>(info.This())) {
        return;
      }

      Window *wrapper = Window::Unwrap<Window>(info.This());

      try  {
        ::Windows::UI::Core::CoreWindow^ result = wrapper->_instance->CoreWindow;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "CoreWindow", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DispatcherGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Window^>(info.This())) {
        return;
      }

      Window *wrapper = Window::Unwrap<Window>(info.This());

      try  {
        ::Windows::UI::Core::CoreDispatcher^ result = wrapper->_instance->Dispatcher;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "CoreDispatcher", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VisibleGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Window^>(info.This())) {
        return;
      }

      Window *wrapper = Window::Unwrap<Window>(info.This());

      try  {
        bool result = wrapper->_instance->Visible;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CompositorGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Window^>(info.This())) {
        return;
      }

      Window *wrapper = Window::Unwrap<Window>(info.This());

      try  {
        ::Windows::UI::Composition::Compositor^ result = wrapper->_instance->Compositor;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Composition", "Compositor", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void UIContextGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Window^>(info.This())) {
        return;
      }

      Window *wrapper = Window::Unwrap<Window>(info.This());

      try  {
        ::Windows::UI::UIContext^ result = wrapper->_instance->UIContext;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI", "UIContext", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    static void CurrentGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::UI::Xaml::Window^ result = ::Windows::UI::Xaml::Window::Current;
        info.GetReturnValue().Set(WrapWindow(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void AddListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"activated", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Window^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        Window *wrapper = Window::Unwrap<Window>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->Activated::add(
            ref new ::Windows::UI::Xaml::WindowActivatedEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Core::WindowActivatedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "WindowActivatedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"closed", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Window^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        Window *wrapper = Window::Unwrap<Window>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->Closed::add(
            ref new ::Windows::UI::Xaml::WindowClosedEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Core::CoreWindowEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "CoreWindowEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"sizeChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Window^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        Window *wrapper = Window::Unwrap<Window>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->SizeChanged::add(
            ref new ::Windows::UI::Xaml::WindowSizeChangedEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Core::WindowSizeChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "WindowSizeChangedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"visibilityChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Window^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        Window *wrapper = Window::Unwrap<Window>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->VisibilityChanged::add(
            ref new ::Windows::UI::Xaml::WindowVisibilityChangedEventHandler(
            [callbackObjPtr](::Platform::Object^ arg0, ::Windows::UI::Core::VisibilityChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "VisibilityChangedEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
 else  {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Value> tokenMapVal = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());
      Local<Object> tokenMap;

      if (tokenMapVal.IsEmpty() || Nan::Equals(tokenMapVal, Undefined()).FromMaybe(false)) {
        tokenMap = Nan::New<Object>();
        NodeRT::Utils::SetHiddenValueWithObject(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked(), tokenMap);
      } else {
        tokenMap = Nan::To<Object>(tokenMapVal).ToLocalChecked();
      }

      Nan::Set(tokenMap, info[0], CreateOpaqueWrapper(::Windows::Foundation::PropertyValue::CreateInt64(registrationToken.Value)));
    }

    static void RemoveListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected a string and a callback")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      if ((!NodeRT::Utils::CaseInsenstiveEquals(L"activated", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"closed", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"sizeChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"visibilityChanged", str))) {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Function> callback = info[1].As<Function>();
      Local<Value> tokenMap = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());

      if (tokenMap.IsEmpty() || Nan::Equals(tokenMap, Undefined()).FromMaybe(false)) {
        return;
      }

      Local<Value> opaqueWrapperObj =  Nan::Get(Nan::To<Object>(tokenMap).ToLocalChecked(), info[0]).ToLocalChecked();

      if (opaqueWrapperObj.IsEmpty() || Nan::Equals(opaqueWrapperObj,Undefined()).FromMaybe(false)) {
        return;
      }

      OpaqueWrapper *opaqueWrapper = OpaqueWrapper::Unwrap<OpaqueWrapper>(opaqueWrapperObj.As<Object>());

      long long tokenValue = (long long) opaqueWrapper->GetObjectInstance();
      ::Windows::Foundation::EventRegistrationToken registrationToken;
      registrationToken.Value = tokenValue;

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"activated", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Window^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          Window *wrapper = Window::Unwrap<Window>(info.This());
          wrapper->_instance->Activated::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"closed", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Window^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          Window *wrapper = Window::Unwrap<Window>(info.This());
          wrapper->_instance->Closed::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"sizeChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Window^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          Window *wrapper = Window::Unwrap<Window>(info.This());
          wrapper->_instance->SizeChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"visibilityChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Window^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          Window *wrapper = Window::Unwrap<Window>(info.This());
          wrapper->_instance->VisibilityChanged::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

      Nan::Delete(Nan::To<Object>(tokenMap).ToLocalChecked(), Nan::To<String>(info[0]).ToLocalChecked());
    }
    private:
      ::Windows::UI::Xaml::Window^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapWindow(::Windows::UI::Xaml::Window^ wintRtInstance);
      friend ::Windows::UI::Xaml::Window^ UnwrapWindow(Local<Value> value);
  };

  Persistent<FunctionTemplate> Window::s_constructorTemplate;

  v8::Local<v8::Value> WrapWindow(::Windows::UI::Xaml::Window^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(Window::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::Window^ UnwrapWindow(Local<Value> value) {
     return Window::Unwrap<Window>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitWindow(Local<Object> exports) {
    Window::Init(exports);
  }

  class WindowCreatedEventArgs : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("WindowCreatedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("window").ToLocalChecked(), WindowGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("WindowCreatedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      WindowCreatedEventArgs(::Windows::UI::Xaml::WindowCreatedEventArgs^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::WindowCreatedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::WindowCreatedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::WindowCreatedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      WindowCreatedEventArgs *wrapperInstance = new WindowCreatedEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::WindowCreatedEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::WindowCreatedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::WindowCreatedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapWindowCreatedEventArgs(winRtInstance));
    }





    static void WindowGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::WindowCreatedEventArgs^>(info.This())) {
        return;
      }

      WindowCreatedEventArgs *wrapper = WindowCreatedEventArgs::Unwrap<WindowCreatedEventArgs>(info.This());

      try  {
        ::Windows::UI::Xaml::Window^ result = wrapper->_instance->Window;
        info.GetReturnValue().Set(WrapWindow(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::WindowCreatedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapWindowCreatedEventArgs(::Windows::UI::Xaml::WindowCreatedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Xaml::WindowCreatedEventArgs^ UnwrapWindowCreatedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> WindowCreatedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapWindowCreatedEventArgs(::Windows::UI::Xaml::WindowCreatedEventArgs^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(WindowCreatedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::WindowCreatedEventArgs^ UnwrapWindowCreatedEventArgs(Local<Value> value) {
     return WindowCreatedEventArgs::Unwrap<WindowCreatedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitWindowCreatedEventArgs(Local<Object> exports) {
    WindowCreatedEventArgs::Init(exports);
  }

  class XamlRoot : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("XamlRoot").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);




          
          Nan::SetPrototypeMethod(localRef,"addListener", AddListener);
          Nan::SetPrototypeMethod(localRef,"on", AddListener);
          Nan::SetPrototypeMethod(localRef,"removeListener", RemoveListener);
          Nan::SetPrototypeMethod(localRef, "off", RemoveListener);

          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("content").ToLocalChecked(), ContentGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isHostVisible").ToLocalChecked(), IsHostVisibleGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("rasterizationScale").ToLocalChecked(), RasterizationScaleGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("size").ToLocalChecked(), SizeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("uIContext").ToLocalChecked(), UIContextGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("XamlRoot").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      XamlRoot(::Windows::UI::Xaml::XamlRoot^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::XamlRoot^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::XamlRoot^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::XamlRoot^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      XamlRoot *wrapperInstance = new XamlRoot(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::XamlRoot^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::XamlRoot^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::XamlRoot^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapXamlRoot(winRtInstance));
    }





    static void ContentGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::XamlRoot^>(info.This())) {
        return;
      }

      XamlRoot *wrapper = XamlRoot::Unwrap<XamlRoot>(info.This());

      try  {
        ::Windows::UI::Xaml::UIElement^ result = wrapper->_instance->Content;
        info.GetReturnValue().Set(WrapUIElement(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsHostVisibleGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::XamlRoot^>(info.This())) {
        return;
      }

      XamlRoot *wrapper = XamlRoot::Unwrap<XamlRoot>(info.This());

      try  {
        bool result = wrapper->_instance->IsHostVisible;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RasterizationScaleGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::XamlRoot^>(info.This())) {
        return;
      }

      XamlRoot *wrapper = XamlRoot::Unwrap<XamlRoot>(info.This());

      try  {
        double result = wrapper->_instance->RasterizationScale;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SizeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::XamlRoot^>(info.This())) {
        return;
      }

      XamlRoot *wrapper = XamlRoot::Unwrap<XamlRoot>(info.This());

      try  {
        ::Windows::Foundation::Size result = wrapper->_instance->Size;
        info.GetReturnValue().Set(NodeRT::Utils::SizeToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void UIContextGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::XamlRoot^>(info.This())) {
        return;
      }

      XamlRoot *wrapper = XamlRoot::Unwrap<XamlRoot>(info.This());

      try  {
        ::Windows::UI::UIContext^ result = wrapper->_instance->UIContext;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI", "UIContext", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    static void AddListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"changed", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::XamlRoot^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        XamlRoot *wrapper = XamlRoot::Unwrap<XamlRoot>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->Changed::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Xaml::XamlRoot^, ::Windows::UI::Xaml::XamlRootChangedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Xaml::XamlRoot^ arg0, ::Windows::UI::Xaml::XamlRootChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapXamlRoot(arg0);
                  wrappedArg1 = WrapXamlRootChangedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
 else  {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Value> tokenMapVal = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());
      Local<Object> tokenMap;

      if (tokenMapVal.IsEmpty() || Nan::Equals(tokenMapVal, Undefined()).FromMaybe(false)) {
        tokenMap = Nan::New<Object>();
        NodeRT::Utils::SetHiddenValueWithObject(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked(), tokenMap);
      } else {
        tokenMap = Nan::To<Object>(tokenMapVal).ToLocalChecked();
      }

      Nan::Set(tokenMap, info[0], CreateOpaqueWrapper(::Windows::Foundation::PropertyValue::CreateInt64(registrationToken.Value)));
    }

    static void RemoveListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected a string and a callback")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      if ((!NodeRT::Utils::CaseInsenstiveEquals(L"changed", str))) {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Function> callback = info[1].As<Function>();
      Local<Value> tokenMap = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());

      if (tokenMap.IsEmpty() || Nan::Equals(tokenMap, Undefined()).FromMaybe(false)) {
        return;
      }

      Local<Value> opaqueWrapperObj =  Nan::Get(Nan::To<Object>(tokenMap).ToLocalChecked(), info[0]).ToLocalChecked();

      if (opaqueWrapperObj.IsEmpty() || Nan::Equals(opaqueWrapperObj,Undefined()).FromMaybe(false)) {
        return;
      }

      OpaqueWrapper *opaqueWrapper = OpaqueWrapper::Unwrap<OpaqueWrapper>(opaqueWrapperObj.As<Object>());

      long long tokenValue = (long long) opaqueWrapper->GetObjectInstance();
      ::Windows::Foundation::EventRegistrationToken registrationToken;
      registrationToken.Value = tokenValue;

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"changed", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::XamlRoot^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          XamlRoot *wrapper = XamlRoot::Unwrap<XamlRoot>(info.This());
          wrapper->_instance->Changed::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

      Nan::Delete(Nan::To<Object>(tokenMap).ToLocalChecked(), Nan::To<String>(info[0]).ToLocalChecked());
    }
    private:
      ::Windows::UI::Xaml::XamlRoot^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapXamlRoot(::Windows::UI::Xaml::XamlRoot^ wintRtInstance);
      friend ::Windows::UI::Xaml::XamlRoot^ UnwrapXamlRoot(Local<Value> value);
  };

  Persistent<FunctionTemplate> XamlRoot::s_constructorTemplate;

  v8::Local<v8::Value> WrapXamlRoot(::Windows::UI::Xaml::XamlRoot^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(XamlRoot::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::XamlRoot^ UnwrapXamlRoot(Local<Value> value) {
     return XamlRoot::Unwrap<XamlRoot>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitXamlRoot(Local<Object> exports) {
    XamlRoot::Init(exports);
  }

  class XamlRootChangedEventArgs : public WrapperBase {
    public:
      
      static void Init(const Local<Object> exports) {
        HandleScope scope;

        Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(New);
        s_constructorTemplate.Reset(localRef);
        localRef->SetClassName(Nan::New<String>("XamlRootChangedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);






        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("XamlRootChangedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      XamlRootChangedEventArgs(::Windows::UI::Xaml::XamlRootChangedEventArgs^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Xaml::XamlRootChangedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::XamlRootChangedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Xaml::XamlRootChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      XamlRootChangedEventArgs *wrapperInstance = new XamlRootChangedEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::XamlRootChangedEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Xaml::XamlRootChangedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Xaml::XamlRootChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapXamlRootChangedEventArgs(winRtInstance));
    }







    private:
      ::Windows::UI::Xaml::XamlRootChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapXamlRootChangedEventArgs(::Windows::UI::Xaml::XamlRootChangedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Xaml::XamlRootChangedEventArgs^ UnwrapXamlRootChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> XamlRootChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapXamlRootChangedEventArgs(::Windows::UI::Xaml::XamlRootChangedEventArgs^ winRtInstance) {
    EscapableHandleScope scope;

    if (winRtInstance == nullptr) {
      return scope.Escape(Undefined());
    }

    Local<Value> opaqueWrapper = CreateOpaqueWrapper(winRtInstance);
    Local<Value> args[] = {opaqueWrapper};
    Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(XamlRootChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Xaml::XamlRootChangedEventArgs^ UnwrapXamlRootChangedEventArgs(Local<Value> value) {
     return XamlRootChangedEventArgs::Unwrap<XamlRootChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitXamlRootChangedEventArgs(Local<Object> exports) {
    XamlRootChangedEventArgs::Init(exports);
  }


} } } } 

NAN_MODULE_INIT(init) {
  // We ignore failures for now since it probably means that
  // the initialization already happened for STA, and that's cool

  CoInitializeEx(nullptr, COINIT_MULTITHREADED);

  /*
  if (FAILED(CoInitializeEx(nullptr, COINIT_MULTITHREADED))) {
    Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"error in CoInitializeEx()")));
    return;
  }
  */

      NodeRT::Windows::UI::Xaml::InitApplicationHighContrastAdjustmentEnum(target);
      NodeRT::Windows::UI::Xaml::InitApplicationRequiresPointerModeEnum(target);
      NodeRT::Windows::UI::Xaml::InitApplicationThemeEnum(target);
      NodeRT::Windows::UI::Xaml::InitAutomationTextAttributesEnumEnum(target);
      NodeRT::Windows::UI::Xaml::InitElementHighContrastAdjustmentEnum(target);
      NodeRT::Windows::UI::Xaml::InitElementSoundKindEnum(target);
      NodeRT::Windows::UI::Xaml::InitElementSoundModeEnum(target);
      NodeRT::Windows::UI::Xaml::InitElementSoundPlayerStateEnum(target);
      NodeRT::Windows::UI::Xaml::InitElementSpatialAudioModeEnum(target);
      NodeRT::Windows::UI::Xaml::InitElementThemeEnum(target);
      NodeRT::Windows::UI::Xaml::InitFlowDirectionEnum(target);
      NodeRT::Windows::UI::Xaml::InitFocusStateEnum(target);
      NodeRT::Windows::UI::Xaml::InitFocusVisualKindEnum(target);
      NodeRT::Windows::UI::Xaml::InitFontCapitalsEnum(target);
      NodeRT::Windows::UI::Xaml::InitFontEastAsianLanguageEnum(target);
      NodeRT::Windows::UI::Xaml::InitFontEastAsianWidthsEnum(target);
      NodeRT::Windows::UI::Xaml::InitFontFractionEnum(target);
      NodeRT::Windows::UI::Xaml::InitFontNumeralAlignmentEnum(target);
      NodeRT::Windows::UI::Xaml::InitFontNumeralStyleEnum(target);
      NodeRT::Windows::UI::Xaml::InitFontVariantsEnum(target);
      NodeRT::Windows::UI::Xaml::InitHorizontalAlignmentEnum(target);
      NodeRT::Windows::UI::Xaml::InitLineStackingStrategyEnum(target);
      NodeRT::Windows::UI::Xaml::InitOpticalMarginAlignmentEnum(target);
      NodeRT::Windows::UI::Xaml::InitTextAlignmentEnum(target);
      NodeRT::Windows::UI::Xaml::InitTextLineBoundsEnum(target);
      NodeRT::Windows::UI::Xaml::InitTextReadingOrderEnum(target);
      NodeRT::Windows::UI::Xaml::InitTextTrimmingEnum(target);
      NodeRT::Windows::UI::Xaml::InitTextWrappingEnum(target);
      NodeRT::Windows::UI::Xaml::InitVector3TransitionComponentsEnum(target);
      NodeRT::Windows::UI::Xaml::InitVerticalAlignmentEnum(target);
      NodeRT::Windows::UI::Xaml::InitVisibilityEnum(target);
      NodeRT::Windows::UI::Xaml::InitDependencyObject(target);
      NodeRT::Windows::UI::Xaml::InitStateTriggerBase(target);
      NodeRT::Windows::UI::Xaml::InitAdaptiveTrigger(target);
      NodeRT::Windows::UI::Xaml::InitApplication(target);
      NodeRT::Windows::UI::Xaml::InitApplicationInitializationCallbackParams(target);
      NodeRT::Windows::UI::Xaml::InitBindingFailedEventArgs(target);
      NodeRT::Windows::UI::Xaml::InitBringIntoViewOptions(target);
      NodeRT::Windows::UI::Xaml::InitRoutedEventArgs(target);
      NodeRT::Windows::UI::Xaml::InitBringIntoViewRequestedEventArgs(target);
      NodeRT::Windows::UI::Xaml::InitBrushTransition(target);
      NodeRT::Windows::UI::Xaml::InitResourceDictionary(target);
      NodeRT::Windows::UI::Xaml::InitColorPaletteResources(target);
      NodeRT::Windows::UI::Xaml::InitUIElement(target);
      NodeRT::Windows::UI::Xaml::InitFrameworkElement(target);
      NodeRT::Windows::UI::Xaml::InitFrameworkTemplate(target);
      NodeRT::Windows::UI::Xaml::InitDataContextChangedEventArgs(target);
      NodeRT::Windows::UI::Xaml::InitDataTemplate(target);
      NodeRT::Windows::UI::Xaml::InitDataTemplateKey(target);
      NodeRT::Windows::UI::Xaml::InitDebugSettings(target);
      NodeRT::Windows::UI::Xaml::InitDependencyObjectCollection(target);
      NodeRT::Windows::UI::Xaml::InitDependencyProperty(target);
      NodeRT::Windows::UI::Xaml::InitDependencyPropertyChangedEventArgs(target);
      NodeRT::Windows::UI::Xaml::InitDispatcherTimer(target);
      NodeRT::Windows::UI::Xaml::InitDragEventArgs(target);
      NodeRT::Windows::UI::Xaml::InitDragOperationDeferral(target);
      NodeRT::Windows::UI::Xaml::InitDragStartingEventArgs(target);
      NodeRT::Windows::UI::Xaml::InitDragUI(target);
      NodeRT::Windows::UI::Xaml::InitDragUIOverride(target);
      NodeRT::Windows::UI::Xaml::InitDropCompletedEventArgs(target);
      NodeRT::Windows::UI::Xaml::InitEffectiveViewportChangedEventArgs(target);
      NodeRT::Windows::UI::Xaml::InitElementFactoryGetArgs(target);
      NodeRT::Windows::UI::Xaml::InitElementFactoryRecycleArgs(target);
      NodeRT::Windows::UI::Xaml::InitElementSoundPlayer(target);
      NodeRT::Windows::UI::Xaml::InitTriggerBase(target);
      NodeRT::Windows::UI::Xaml::InitEventTrigger(target);
      NodeRT::Windows::UI::Xaml::InitExceptionRoutedEventArgs(target);
      NodeRT::Windows::UI::Xaml::InitFrameworkView(target);
      NodeRT::Windows::UI::Xaml::InitFrameworkViewSource(target);
      NodeRT::Windows::UI::Xaml::InitIDataTemplateExtension(target);
      NodeRT::Windows::UI::Xaml::InitIElementFactory(target);
      NodeRT::Windows::UI::Xaml::InitTriggerAction(target);
      NodeRT::Windows::UI::Xaml::InitMediaFailedRoutedEventArgs(target);
      NodeRT::Windows::UI::Xaml::InitPointHelper(target);
      NodeRT::Windows::UI::Xaml::InitPropertyMetadata(target);
      NodeRT::Windows::UI::Xaml::InitPropertyPath(target);
      NodeRT::Windows::UI::Xaml::InitRectHelper(target);
      NodeRT::Windows::UI::Xaml::InitRoutedEvent(target);
      NodeRT::Windows::UI::Xaml::InitScalarTransition(target);
      NodeRT::Windows::UI::Xaml::InitSetterBase(target);
      NodeRT::Windows::UI::Xaml::InitSetter(target);
      NodeRT::Windows::UI::Xaml::InitSetterBaseCollection(target);
      NodeRT::Windows::UI::Xaml::InitSizeChangedEventArgs(target);
      NodeRT::Windows::UI::Xaml::InitSizeHelper(target);
      NodeRT::Windows::UI::Xaml::InitStateTrigger(target);
      NodeRT::Windows::UI::Xaml::InitStyle(target);
      NodeRT::Windows::UI::Xaml::InitStyleTypedPropertyAttribute(target);
      NodeRT::Windows::UI::Xaml::InitTargetPropertyPath(target);
      NodeRT::Windows::UI::Xaml::InitTemplatePartAttribute(target);
      NodeRT::Windows::UI::Xaml::InitTemplateVisualStateAttribute(target);
      NodeRT::Windows::UI::Xaml::InitTriggerActionCollection(target);
      NodeRT::Windows::UI::Xaml::InitTriggerCollection(target);
      NodeRT::Windows::UI::Xaml::InitUIElementWeakCollection(target);
      NodeRT::Windows::UI::Xaml::InitUnhandledExceptionEventArgs(target);
      NodeRT::Windows::UI::Xaml::InitVector3Transition(target);
      NodeRT::Windows::UI::Xaml::InitVisualState(target);
      NodeRT::Windows::UI::Xaml::InitVisualStateChangedEventArgs(target);
      NodeRT::Windows::UI::Xaml::InitVisualStateGroup(target);
      NodeRT::Windows::UI::Xaml::InitVisualStateManager(target);
      NodeRT::Windows::UI::Xaml::InitVisualTransition(target);
      NodeRT::Windows::UI::Xaml::InitWindow(target);
      NodeRT::Windows::UI::Xaml::InitWindowCreatedEventArgs(target);
      NodeRT::Windows::UI::Xaml::InitXamlRoot(target);
      NodeRT::Windows::UI::Xaml::InitXamlRootChangedEventArgs(target);


  NodeRT::Utils::RegisterNameSpace("Windows.UI.Xaml", target);
}



NODE_MODULE(binding, init)