// 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 Input { 
  v8::Local<v8::Value> WrapAttachableInputObject(::Windows::UI::Input::AttachableInputObject^ wintRtInstance);
  ::Windows::UI::Input::AttachableInputObject^ UnwrapAttachableInputObject(Local<Value> value);
  
  v8::Local<v8::Value> WrapCrossSlidingEventArgs(::Windows::UI::Input::CrossSlidingEventArgs^ wintRtInstance);
  ::Windows::UI::Input::CrossSlidingEventArgs^ UnwrapCrossSlidingEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapDraggingEventArgs(::Windows::UI::Input::DraggingEventArgs^ wintRtInstance);
  ::Windows::UI::Input::DraggingEventArgs^ UnwrapDraggingEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapEdgeGesture(::Windows::UI::Input::EdgeGesture^ wintRtInstance);
  ::Windows::UI::Input::EdgeGesture^ UnwrapEdgeGesture(Local<Value> value);
  
  v8::Local<v8::Value> WrapEdgeGestureEventArgs(::Windows::UI::Input::EdgeGestureEventArgs^ wintRtInstance);
  ::Windows::UI::Input::EdgeGestureEventArgs^ UnwrapEdgeGestureEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapGestureRecognizer(::Windows::UI::Input::GestureRecognizer^ wintRtInstance);
  ::Windows::UI::Input::GestureRecognizer^ UnwrapGestureRecognizer(Local<Value> value);
  
  v8::Local<v8::Value> WrapHoldingEventArgs(::Windows::UI::Input::HoldingEventArgs^ wintRtInstance);
  ::Windows::UI::Input::HoldingEventArgs^ UnwrapHoldingEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapIPointerPointTransform(::Windows::UI::Input::IPointerPointTransform^ wintRtInstance);
  ::Windows::UI::Input::IPointerPointTransform^ UnwrapIPointerPointTransform(Local<Value> value);
  
  v8::Local<v8::Value> WrapInputActivationListener(::Windows::UI::Input::InputActivationListener^ wintRtInstance);
  ::Windows::UI::Input::InputActivationListener^ UnwrapInputActivationListener(Local<Value> value);
  
  v8::Local<v8::Value> WrapInputActivationListenerActivationChangedEventArgs(::Windows::UI::Input::InputActivationListenerActivationChangedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::InputActivationListenerActivationChangedEventArgs^ UnwrapInputActivationListenerActivationChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapKeyboardDeliveryInterceptor(::Windows::UI::Input::KeyboardDeliveryInterceptor^ wintRtInstance);
  ::Windows::UI::Input::KeyboardDeliveryInterceptor^ UnwrapKeyboardDeliveryInterceptor(Local<Value> value);
  
  v8::Local<v8::Value> WrapManipulationCompletedEventArgs(::Windows::UI::Input::ManipulationCompletedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::ManipulationCompletedEventArgs^ UnwrapManipulationCompletedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapManipulationInertiaStartingEventArgs(::Windows::UI::Input::ManipulationInertiaStartingEventArgs^ wintRtInstance);
  ::Windows::UI::Input::ManipulationInertiaStartingEventArgs^ UnwrapManipulationInertiaStartingEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapManipulationStartedEventArgs(::Windows::UI::Input::ManipulationStartedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::ManipulationStartedEventArgs^ UnwrapManipulationStartedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapManipulationUpdatedEventArgs(::Windows::UI::Input::ManipulationUpdatedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::ManipulationUpdatedEventArgs^ UnwrapManipulationUpdatedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapMouseWheelParameters(::Windows::UI::Input::MouseWheelParameters^ wintRtInstance);
  ::Windows::UI::Input::MouseWheelParameters^ UnwrapMouseWheelParameters(Local<Value> value);
  
  v8::Local<v8::Value> WrapPointerPoint(::Windows::UI::Input::PointerPoint^ wintRtInstance);
  ::Windows::UI::Input::PointerPoint^ UnwrapPointerPoint(Local<Value> value);
  
  v8::Local<v8::Value> WrapPointerPointProperties(::Windows::UI::Input::PointerPointProperties^ wintRtInstance);
  ::Windows::UI::Input::PointerPointProperties^ UnwrapPointerPointProperties(Local<Value> value);
  
  v8::Local<v8::Value> WrapPointerVisualizationSettings(::Windows::UI::Input::PointerVisualizationSettings^ wintRtInstance);
  ::Windows::UI::Input::PointerVisualizationSettings^ UnwrapPointerVisualizationSettings(Local<Value> value);
  
  v8::Local<v8::Value> WrapRadialController(::Windows::UI::Input::RadialController^ wintRtInstance);
  ::Windows::UI::Input::RadialController^ UnwrapRadialController(Local<Value> value);
  
  v8::Local<v8::Value> WrapRadialControllerButtonClickedEventArgs(::Windows::UI::Input::RadialControllerButtonClickedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::RadialControllerButtonClickedEventArgs^ UnwrapRadialControllerButtonClickedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapRadialControllerButtonHoldingEventArgs(::Windows::UI::Input::RadialControllerButtonHoldingEventArgs^ wintRtInstance);
  ::Windows::UI::Input::RadialControllerButtonHoldingEventArgs^ UnwrapRadialControllerButtonHoldingEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapRadialControllerButtonPressedEventArgs(::Windows::UI::Input::RadialControllerButtonPressedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::RadialControllerButtonPressedEventArgs^ UnwrapRadialControllerButtonPressedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapRadialControllerButtonReleasedEventArgs(::Windows::UI::Input::RadialControllerButtonReleasedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::RadialControllerButtonReleasedEventArgs^ UnwrapRadialControllerButtonReleasedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapRadialControllerConfiguration(::Windows::UI::Input::RadialControllerConfiguration^ wintRtInstance);
  ::Windows::UI::Input::RadialControllerConfiguration^ UnwrapRadialControllerConfiguration(Local<Value> value);
  
  v8::Local<v8::Value> WrapRadialControllerControlAcquiredEventArgs(::Windows::UI::Input::RadialControllerControlAcquiredEventArgs^ wintRtInstance);
  ::Windows::UI::Input::RadialControllerControlAcquiredEventArgs^ UnwrapRadialControllerControlAcquiredEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapRadialControllerMenu(::Windows::UI::Input::RadialControllerMenu^ wintRtInstance);
  ::Windows::UI::Input::RadialControllerMenu^ UnwrapRadialControllerMenu(Local<Value> value);
  
  v8::Local<v8::Value> WrapRadialControllerMenuItem(::Windows::UI::Input::RadialControllerMenuItem^ wintRtInstance);
  ::Windows::UI::Input::RadialControllerMenuItem^ UnwrapRadialControllerMenuItem(Local<Value> value);
  
  v8::Local<v8::Value> WrapRadialControllerRotationChangedEventArgs(::Windows::UI::Input::RadialControllerRotationChangedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::RadialControllerRotationChangedEventArgs^ UnwrapRadialControllerRotationChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapRadialControllerScreenContact(::Windows::UI::Input::RadialControllerScreenContact^ wintRtInstance);
  ::Windows::UI::Input::RadialControllerScreenContact^ UnwrapRadialControllerScreenContact(Local<Value> value);
  
  v8::Local<v8::Value> WrapRadialControllerScreenContactContinuedEventArgs(::Windows::UI::Input::RadialControllerScreenContactContinuedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::RadialControllerScreenContactContinuedEventArgs^ UnwrapRadialControllerScreenContactContinuedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapRadialControllerScreenContactEndedEventArgs(::Windows::UI::Input::RadialControllerScreenContactEndedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::RadialControllerScreenContactEndedEventArgs^ UnwrapRadialControllerScreenContactEndedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapRadialControllerScreenContactStartedEventArgs(::Windows::UI::Input::RadialControllerScreenContactStartedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::RadialControllerScreenContactStartedEventArgs^ UnwrapRadialControllerScreenContactStartedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapRightTappedEventArgs(::Windows::UI::Input::RightTappedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::RightTappedEventArgs^ UnwrapRightTappedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapSystemButtonEventController(::Windows::UI::Input::SystemButtonEventController^ wintRtInstance);
  ::Windows::UI::Input::SystemButtonEventController^ UnwrapSystemButtonEventController(Local<Value> value);
  
  v8::Local<v8::Value> WrapSystemFunctionButtonEventArgs(::Windows::UI::Input::SystemFunctionButtonEventArgs^ wintRtInstance);
  ::Windows::UI::Input::SystemFunctionButtonEventArgs^ UnwrapSystemFunctionButtonEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapSystemFunctionLockChangedEventArgs(::Windows::UI::Input::SystemFunctionLockChangedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::SystemFunctionLockChangedEventArgs^ UnwrapSystemFunctionLockChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapSystemFunctionLockIndicatorChangedEventArgs(::Windows::UI::Input::SystemFunctionLockIndicatorChangedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::SystemFunctionLockIndicatorChangedEventArgs^ UnwrapSystemFunctionLockIndicatorChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapTappedEventArgs(::Windows::UI::Input::TappedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::TappedEventArgs^ UnwrapTappedEventArgs(Local<Value> value);
  



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

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

    Nan::Set(exports, Nan::New<String>("CrossSlidingState").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("started").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::CrossSlidingState::Started)));
    Nan::Set(enumObject, Nan::New<String>("dragging").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::CrossSlidingState::Dragging)));
    Nan::Set(enumObject, Nan::New<String>("selecting").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::CrossSlidingState::Selecting)));
    Nan::Set(enumObject, Nan::New<String>("selectSpeedBumping").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::CrossSlidingState::SelectSpeedBumping)));
    Nan::Set(enumObject, Nan::New<String>("speedBumping").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::CrossSlidingState::SpeedBumping)));
    Nan::Set(enumObject, Nan::New<String>("rearranging").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::CrossSlidingState::Rearranging)));
    Nan::Set(enumObject, Nan::New<String>("completed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::CrossSlidingState::Completed)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("DraggingState").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("started").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::DraggingState::Started)));
    Nan::Set(enumObject, Nan::New<String>("continuing").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::DraggingState::Continuing)));
    Nan::Set(enumObject, Nan::New<String>("completed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::DraggingState::Completed)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("EdgeGestureKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("touch").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::EdgeGestureKind::Touch)));
    Nan::Set(enumObject, Nan::New<String>("keyboard").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::EdgeGestureKind::Keyboard)));
    Nan::Set(enumObject, Nan::New<String>("mouse").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::EdgeGestureKind::Mouse)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("GazeInputAccessStatus").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("unspecified").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::GazeInputAccessStatus::Unspecified)));
    Nan::Set(enumObject, Nan::New<String>("allowed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::GazeInputAccessStatus::Allowed)));
    Nan::Set(enumObject, Nan::New<String>("deniedByUser").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::GazeInputAccessStatus::DeniedByUser)));
    Nan::Set(enumObject, Nan::New<String>("deniedBySystem").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::GazeInputAccessStatus::DeniedBySystem)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("GestureSettings").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::GestureSettings::None)));
    Nan::Set(enumObject, Nan::New<String>("tap").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::GestureSettings::Tap)));
    Nan::Set(enumObject, Nan::New<String>("doubleTap").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::GestureSettings::DoubleTap)));
    Nan::Set(enumObject, Nan::New<String>("hold").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::GestureSettings::Hold)));
    Nan::Set(enumObject, Nan::New<String>("holdWithMouse").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::GestureSettings::HoldWithMouse)));
    Nan::Set(enumObject, Nan::New<String>("rightTap").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::GestureSettings::RightTap)));
    Nan::Set(enumObject, Nan::New<String>("drag").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::GestureSettings::Drag)));
    Nan::Set(enumObject, Nan::New<String>("manipulationTranslateX").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::GestureSettings::ManipulationTranslateX)));
    Nan::Set(enumObject, Nan::New<String>("manipulationTranslateY").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::GestureSettings::ManipulationTranslateY)));
    Nan::Set(enumObject, Nan::New<String>("manipulationTranslateRailsX").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::GestureSettings::ManipulationTranslateRailsX)));
    Nan::Set(enumObject, Nan::New<String>("manipulationTranslateRailsY").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::GestureSettings::ManipulationTranslateRailsY)));
    Nan::Set(enumObject, Nan::New<String>("manipulationRotate").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::GestureSettings::ManipulationRotate)));
    Nan::Set(enumObject, Nan::New<String>("manipulationScale").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::GestureSettings::ManipulationScale)));
    Nan::Set(enumObject, Nan::New<String>("manipulationTranslateInertia").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::GestureSettings::ManipulationTranslateInertia)));
    Nan::Set(enumObject, Nan::New<String>("manipulationRotateInertia").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::GestureSettings::ManipulationRotateInertia)));
    Nan::Set(enumObject, Nan::New<String>("manipulationScaleInertia").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::GestureSettings::ManipulationScaleInertia)));
    Nan::Set(enumObject, Nan::New<String>("crossSlide").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::GestureSettings::CrossSlide)));
    Nan::Set(enumObject, Nan::New<String>("manipulationMultipleFingerPanning").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::GestureSettings::ManipulationMultipleFingerPanning)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("HoldingState").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("started").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::HoldingState::Started)));
    Nan::Set(enumObject, Nan::New<String>("completed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::HoldingState::Completed)));
    Nan::Set(enumObject, Nan::New<String>("canceled").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::HoldingState::Canceled)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("InputActivationState").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::InputActivationState::None)));
    Nan::Set(enumObject, Nan::New<String>("deactivated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::InputActivationState::Deactivated)));
    Nan::Set(enumObject, Nan::New<String>("activatedNotForeground").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::InputActivationState::ActivatedNotForeground)));
    Nan::Set(enumObject, Nan::New<String>("activatedInForeground").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::InputActivationState::ActivatedInForeground)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("PointerUpdateKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("other").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::PointerUpdateKind::Other)));
    Nan::Set(enumObject, Nan::New<String>("leftButtonPressed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::PointerUpdateKind::LeftButtonPressed)));
    Nan::Set(enumObject, Nan::New<String>("leftButtonReleased").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::PointerUpdateKind::LeftButtonReleased)));
    Nan::Set(enumObject, Nan::New<String>("rightButtonPressed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::PointerUpdateKind::RightButtonPressed)));
    Nan::Set(enumObject, Nan::New<String>("rightButtonReleased").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::PointerUpdateKind::RightButtonReleased)));
    Nan::Set(enumObject, Nan::New<String>("middleButtonPressed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::PointerUpdateKind::MiddleButtonPressed)));
    Nan::Set(enumObject, Nan::New<String>("middleButtonReleased").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::PointerUpdateKind::MiddleButtonReleased)));
    Nan::Set(enumObject, Nan::New<String>("xButton1Pressed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::PointerUpdateKind::XButton1Pressed)));
    Nan::Set(enumObject, Nan::New<String>("xButton1Released").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::PointerUpdateKind::XButton1Released)));
    Nan::Set(enumObject, Nan::New<String>("xButton2Pressed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::PointerUpdateKind::XButton2Pressed)));
    Nan::Set(enumObject, Nan::New<String>("xButton2Released").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::PointerUpdateKind::XButton2Released)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("RadialControllerMenuKnownIcon").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("scroll").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::RadialControllerMenuKnownIcon::Scroll)));
    Nan::Set(enumObject, Nan::New<String>("zoom").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::RadialControllerMenuKnownIcon::Zoom)));
    Nan::Set(enumObject, Nan::New<String>("undoRedo").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::RadialControllerMenuKnownIcon::UndoRedo)));
    Nan::Set(enumObject, Nan::New<String>("volume").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::RadialControllerMenuKnownIcon::Volume)));
    Nan::Set(enumObject, Nan::New<String>("nextPreviousTrack").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::RadialControllerMenuKnownIcon::NextPreviousTrack)));
    Nan::Set(enumObject, Nan::New<String>("ruler").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::RadialControllerMenuKnownIcon::Ruler)));
    Nan::Set(enumObject, Nan::New<String>("inkColor").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::RadialControllerMenuKnownIcon::InkColor)));
    Nan::Set(enumObject, Nan::New<String>("inkThickness").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::RadialControllerMenuKnownIcon::InkThickness)));
    Nan::Set(enumObject, Nan::New<String>("penType").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::RadialControllerMenuKnownIcon::PenType)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("RadialControllerSystemMenuItemKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("scroll").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::RadialControllerSystemMenuItemKind::Scroll)));
    Nan::Set(enumObject, Nan::New<String>("zoom").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::RadialControllerSystemMenuItemKind::Zoom)));
    Nan::Set(enumObject, Nan::New<String>("undoRedo").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::RadialControllerSystemMenuItemKind::UndoRedo)));
    Nan::Set(enumObject, Nan::New<String>("volume").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::RadialControllerSystemMenuItemKind::Volume)));
    Nan::Set(enumObject, Nan::New<String>("nextPreviousTrack").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::RadialControllerSystemMenuItemKind::NextPreviousTrack)));
  }

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

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

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

  ::Windows::UI::Input::CrossSlideThresholds CrossSlideThresholdsFromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::UI::Input::CrossSlideThresholds 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>("selectionStart").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.SelectionStart = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("speedBumpStart").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.SpeedBumpStart = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("speedBumpEnd").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.SpeedBumpEnd = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("rearrangeStart").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.RearrangeStart = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    return returnValue;
  }

  Local<Value> CrossSlideThresholdsToJsObject(::Windows::UI::Input::CrossSlideThresholds value) {
    EscapableHandleScope scope;

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

    Nan::Set(obj, Nan::New<String>("selectionStart").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.SelectionStart)));
    Nan::Set(obj, Nan::New<String>("speedBumpStart").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.SpeedBumpStart)));
    Nan::Set(obj, Nan::New<String>("speedBumpEnd").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.SpeedBumpEnd)));
    Nan::Set(obj, Nan::New<String>("rearrangeStart").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.RearrangeStart)));

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

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

    symbol = Nan::New<String>("translation").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!NodeRT::Utils::IsPoint(Nan::Get(obj,symbol).ToLocalChecked())) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("scale").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("rotation").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("expansion").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    return true;
  }

  ::Windows::UI::Input::ManipulationDelta ManipulationDeltaFromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::UI::Input::ManipulationDelta 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>("translation").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.Translation = NodeRT::Utils::PointFromJs(Nan::Get(obj,symbol).ToLocalChecked());
    }
    
    symbol = Nan::New<String>("scale").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.Scale = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("rotation").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.Rotation = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("expansion").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.Expansion = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    return returnValue;
  }

  Local<Value> ManipulationDeltaToJsObject(::Windows::UI::Input::ManipulationDelta value) {
    EscapableHandleScope scope;

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

    Nan::Set(obj, Nan::New<String>("translation").ToLocalChecked(), NodeRT::Utils::PointToJs(value.Translation));
    Nan::Set(obj, Nan::New<String>("scale").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.Scale)));
    Nan::Set(obj, Nan::New<String>("rotation").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.Rotation)));
    Nan::Set(obj, Nan::New<String>("expansion").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.Expansion)));

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

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

    symbol = Nan::New<String>("linear").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!NodeRT::Utils::IsPoint(Nan::Get(obj,symbol).ToLocalChecked())) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("angular").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("expansion").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    return true;
  }

  ::Windows::UI::Input::ManipulationVelocities ManipulationVelocitiesFromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::UI::Input::ManipulationVelocities 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>("linear").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.Linear = NodeRT::Utils::PointFromJs(Nan::Get(obj,symbol).ToLocalChecked());
    }
    
    symbol = Nan::New<String>("angular").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.Angular = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("expansion").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.Expansion = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    return returnValue;
  }

  Local<Value> ManipulationVelocitiesToJsObject(::Windows::UI::Input::ManipulationVelocities value) {
    EscapableHandleScope scope;

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

    Nan::Set(obj, Nan::New<String>("linear").ToLocalChecked(), NodeRT::Utils::PointToJs(value.Linear));
    Nan::Set(obj, Nan::New<String>("angular").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.Angular)));
    Nan::Set(obj, Nan::New<String>("expansion").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.Expansion)));

    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 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);
  }

  class AttachableInputObject : 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>("AttachableInputObject").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "close", Close);
          




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



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

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

    private:

      AttachableInputObject(::Windows::UI::Input::AttachableInputObject^ 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::Input::AttachableInputObject^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::AttachableInputObject^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::AttachableInputObject^) 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());

      AttachableInputObject *wrapperInstance = new AttachableInputObject(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::Input::AttachableInputObject^>(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::Input::AttachableInputObject^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::AttachableInputObject^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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



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

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

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

      if (info.Length() == 0) {
        try {
          delete wrapper->_instance;
          wrapper->_instance = nullptr;
          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::Input::AttachableInputObject^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAttachableInputObject(::Windows::UI::Input::AttachableInputObject^ wintRtInstance);
      friend ::Windows::UI::Input::AttachableInputObject^ UnwrapAttachableInputObject(Local<Value> value);
  };

  Persistent<FunctionTemplate> AttachableInputObject::s_constructorTemplate;

  v8::Local<v8::Value> WrapAttachableInputObject(::Windows::UI::Input::AttachableInputObject^ 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>(AttachableInputObject::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::AttachableInputObject^ UnwrapAttachableInputObject(Local<Value> value) {
     return AttachableInputObject::Unwrap<AttachableInputObject>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAttachableInputObject(Local<Object> exports) {
    AttachableInputObject::Init(exports);
  }

  class CrossSlidingEventArgs : 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>("CrossSlidingEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("crossSlidingState").ToLocalChecked(), CrossSlidingStateGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pointerDeviceType").ToLocalChecked(), PointerDeviceTypeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("position").ToLocalChecked(), PositionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("contactCount").ToLocalChecked(), ContactCountGetter);

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



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

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

    private:

      CrossSlidingEventArgs(::Windows::UI::Input::CrossSlidingEventArgs^ 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::Input::CrossSlidingEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::CrossSlidingEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::CrossSlidingEventArgs^) 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());

      CrossSlidingEventArgs *wrapperInstance = new CrossSlidingEventArgs(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::Input::CrossSlidingEventArgs^>(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::Input::CrossSlidingEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::CrossSlidingEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

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

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

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

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

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

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

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

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

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

      try  {
        unsigned int result = wrapper->_instance->ContactCount;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::CrossSlidingEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapCrossSlidingEventArgs(::Windows::UI::Input::CrossSlidingEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::CrossSlidingEventArgs^ UnwrapCrossSlidingEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> CrossSlidingEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapCrossSlidingEventArgs(::Windows::UI::Input::CrossSlidingEventArgs^ 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>(CrossSlidingEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::CrossSlidingEventArgs^ UnwrapCrossSlidingEventArgs(Local<Value> value) {
     return CrossSlidingEventArgs::Unwrap<CrossSlidingEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitCrossSlidingEventArgs(Local<Object> exports) {
    CrossSlidingEventArgs::Init(exports);
  }

  class DraggingEventArgs : 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>("DraggingEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("draggingState").ToLocalChecked(), DraggingStateGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pointerDeviceType").ToLocalChecked(), PointerDeviceTypeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("position").ToLocalChecked(), PositionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("contactCount").ToLocalChecked(), ContactCountGetter);

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



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

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

    private:

      DraggingEventArgs(::Windows::UI::Input::DraggingEventArgs^ 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::Input::DraggingEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::DraggingEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::DraggingEventArgs^) 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());

      DraggingEventArgs *wrapperInstance = new DraggingEventArgs(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::Input::DraggingEventArgs^>(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::Input::DraggingEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::DraggingEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

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

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

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

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

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

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

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

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

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

      try  {
        unsigned int result = wrapper->_instance->ContactCount;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::DraggingEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapDraggingEventArgs(::Windows::UI::Input::DraggingEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::DraggingEventArgs^ UnwrapDraggingEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> DraggingEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapDraggingEventArgs(::Windows::UI::Input::DraggingEventArgs^ 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>(DraggingEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::DraggingEventArgs^ UnwrapDraggingEventArgs(Local<Value> value) {
     return DraggingEventArgs::Unwrap<DraggingEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitDraggingEventArgs(Local<Object> exports) {
    DraggingEventArgs::Init(exports);
  }

  class EdgeGesture : 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>("EdgeGesture").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);


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

        Nan::SetMethod(constructor, "getForCurrentView", GetForCurrentView);


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

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

    private:

      EdgeGesture(::Windows::UI::Input::EdgeGesture^ 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::Input::EdgeGesture^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::EdgeGesture^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::EdgeGesture^) 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());

      EdgeGesture *wrapperInstance = new EdgeGesture(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::Input::EdgeGesture^>(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::Input::EdgeGesture^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::EdgeGesture^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::UI::Input::EdgeGesture^ result;
          result = ::Windows::UI::Input::EdgeGesture::GetForCurrentView();
          info.GetReturnValue().Set(WrapEdgeGesture(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 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"canceled", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::EdgeGesture^>(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;
        }
        EdgeGesture *wrapper = EdgeGesture::Unwrap<EdgeGesture>(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->Canceled::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::EdgeGesture^, ::Windows::UI::Input::EdgeGestureEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::EdgeGesture^ arg0, ::Windows::UI::Input::EdgeGestureEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapEdgeGesture(arg0);
                  wrappedArg1 = WrapEdgeGestureEventArgs(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"completed", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::EdgeGesture^>(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;
        }
        EdgeGesture *wrapper = EdgeGesture::Unwrap<EdgeGesture>(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->Completed::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::EdgeGesture^, ::Windows::UI::Input::EdgeGestureEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::EdgeGesture^ arg0, ::Windows::UI::Input::EdgeGestureEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapEdgeGesture(arg0);
                  wrappedArg1 = WrapEdgeGestureEventArgs(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"starting", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::EdgeGesture^>(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;
        }
        EdgeGesture *wrapper = EdgeGesture::Unwrap<EdgeGesture>(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->Starting::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::EdgeGesture^, ::Windows::UI::Input::EdgeGestureEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::EdgeGesture^ arg0, ::Windows::UI::Input::EdgeGestureEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapEdgeGesture(arg0);
                  wrappedArg1 = WrapEdgeGestureEventArgs(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"canceled", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"completed", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"starting", 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"canceled", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::EdgeGesture^>(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;
          }
          EdgeGesture *wrapper = EdgeGesture::Unwrap<EdgeGesture>(info.This());
          wrapper->_instance->Canceled::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"completed", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::EdgeGesture^>(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;
          }
          EdgeGesture *wrapper = EdgeGesture::Unwrap<EdgeGesture>(info.This());
          wrapper->_instance->Completed::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"starting", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::EdgeGesture^>(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;
          }
          EdgeGesture *wrapper = EdgeGesture::Unwrap<EdgeGesture>(info.This());
          wrapper->_instance->Starting::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::Input::EdgeGesture^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapEdgeGesture(::Windows::UI::Input::EdgeGesture^ wintRtInstance);
      friend ::Windows::UI::Input::EdgeGesture^ UnwrapEdgeGesture(Local<Value> value);
  };

  Persistent<FunctionTemplate> EdgeGesture::s_constructorTemplate;

  v8::Local<v8::Value> WrapEdgeGesture(::Windows::UI::Input::EdgeGesture^ 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>(EdgeGesture::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::EdgeGesture^ UnwrapEdgeGesture(Local<Value> value) {
     return EdgeGesture::Unwrap<EdgeGesture>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitEdgeGesture(Local<Object> exports) {
    EdgeGesture::Init(exports);
  }

  class EdgeGestureEventArgs : 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>("EdgeGestureEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





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

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



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

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

    private:

      EdgeGestureEventArgs(::Windows::UI::Input::EdgeGestureEventArgs^ 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::Input::EdgeGestureEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::EdgeGestureEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::EdgeGestureEventArgs^) 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());

      EdgeGestureEventArgs *wrapperInstance = new EdgeGestureEventArgs(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::Input::EdgeGestureEventArgs^>(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::Input::EdgeGestureEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::EdgeGestureEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

      try  {
        ::Windows::UI::Input::EdgeGestureKind result = wrapper->_instance->Kind;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::EdgeGestureEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapEdgeGestureEventArgs(::Windows::UI::Input::EdgeGestureEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::EdgeGestureEventArgs^ UnwrapEdgeGestureEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> EdgeGestureEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapEdgeGestureEventArgs(::Windows::UI::Input::EdgeGestureEventArgs^ 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>(EdgeGestureEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::EdgeGestureEventArgs^ UnwrapEdgeGestureEventArgs(Local<Value> value) {
     return EdgeGestureEventArgs::Unwrap<EdgeGestureEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitEdgeGestureEventArgs(Local<Object> exports) {
    EdgeGestureEventArgs::Init(exports);
  }

  class GestureRecognizer : 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>("GestureRecognizer").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "canBeDoubleTap", CanBeDoubleTap);
            Nan::SetPrototypeMethod(localRef, "processDownEvent", ProcessDownEvent);
            Nan::SetPrototypeMethod(localRef, "processMoveEvents", ProcessMoveEvents);
            Nan::SetPrototypeMethod(localRef, "processUpEvent", ProcessUpEvent);
            Nan::SetPrototypeMethod(localRef, "processMouseWheelEvent", ProcessMouseWheelEvent);
            Nan::SetPrototypeMethod(localRef, "processInertia", ProcessInertia);
            Nan::SetPrototypeMethod(localRef, "completeGesture", CompleteGesture);
          


          
          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>("showGestureFeedback").ToLocalChecked(), ShowGestureFeedbackGetter, ShowGestureFeedbackSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pivotRadius").ToLocalChecked(), PivotRadiusGetter, PivotRadiusSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pivotCenter").ToLocalChecked(), PivotCenterGetter, PivotCenterSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("manipulationExact").ToLocalChecked(), ManipulationExactGetter, ManipulationExactSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("inertiaTranslationDisplacement").ToLocalChecked(), InertiaTranslationDisplacementGetter, InertiaTranslationDisplacementSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("inertiaTranslationDeceleration").ToLocalChecked(), InertiaTranslationDecelerationGetter, InertiaTranslationDecelerationSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("inertiaRotationDeceleration").ToLocalChecked(), InertiaRotationDecelerationGetter, InertiaRotationDecelerationSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("inertiaRotationAngle").ToLocalChecked(), InertiaRotationAngleGetter, InertiaRotationAngleSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("inertiaExpansionDeceleration").ToLocalChecked(), InertiaExpansionDecelerationGetter, InertiaExpansionDecelerationSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("inertiaExpansion").ToLocalChecked(), InertiaExpansionGetter, InertiaExpansionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("gestureSettings").ToLocalChecked(), GestureSettingsGetter, GestureSettingsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("crossSlideThresholds").ToLocalChecked(), CrossSlideThresholdsGetter, CrossSlideThresholdsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("crossSlideHorizontally").ToLocalChecked(), CrossSlideHorizontallyGetter, CrossSlideHorizontallySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("crossSlideExact").ToLocalChecked(), CrossSlideExactGetter, CrossSlideExactSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("autoProcessInertia").ToLocalChecked(), AutoProcessInertiaGetter, AutoProcessInertiaSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isActive").ToLocalChecked(), IsActiveGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isInertial").ToLocalChecked(), IsInertialGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("mouseWheelParameters").ToLocalChecked(), MouseWheelParametersGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("translationMinContactCount").ToLocalChecked(), TranslationMinContactCountGetter, TranslationMinContactCountSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("translationMaxContactCount").ToLocalChecked(), TranslationMaxContactCountGetter, TranslationMaxContactCountSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("tapMinContactCount").ToLocalChecked(), TapMinContactCountGetter, TapMinContactCountSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("tapMaxContactCount").ToLocalChecked(), TapMaxContactCountGetter, TapMaxContactCountSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("holdStartDelay").ToLocalChecked(), HoldStartDelayGetter, HoldStartDelaySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("holdRadius").ToLocalChecked(), HoldRadiusGetter, HoldRadiusSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("holdMinContactCount").ToLocalChecked(), HoldMinContactCountGetter, HoldMinContactCountSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("holdMaxContactCount").ToLocalChecked(), HoldMaxContactCountGetter, HoldMaxContactCountSetter);

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



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

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

    private:

      GestureRecognizer(::Windows::UI::Input::GestureRecognizer^ 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::Input::GestureRecognizer^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::GestureRecognizer^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::GestureRecognizer^) 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::Input::GestureRecognizer();
        } 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());

      GestureRecognizer *wrapperInstance = new GestureRecognizer(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::Input::GestureRecognizer^>(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::Input::GestureRecognizer^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::GestureRecognizer^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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


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

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::PointerPoint^>(info[0]))
      {
        try
        {
          ::Windows::UI::Input::PointerPoint^ arg0 = UnwrapPointerPoint(info[0]);
          
          bool result;
          result = wrapper->_instance->CanBeDoubleTap(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 ProcessDownEvent(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::PointerPoint^>(info[0]))
      {
        try
        {
          ::Windows::UI::Input::PointerPoint^ arg0 = UnwrapPointerPoint(info[0]);
          
          wrapper->_instance->ProcessDownEvent(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 ProcessMoveEvents(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IVector<::Windows::UI::Input::PointerPoint^>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IVector<::Windows::UI::Input::PointerPoint^>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IVector<::Windows::UI::Input::PointerPoint^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::UI::Input::PointerPoint^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::PointerPoint^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::UI::Input::PointerPoint^ {
                   return UnwrapPointerPoint(value);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IVector<::Windows::UI::Input::PointerPoint^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          wrapper->_instance->ProcessMoveEvents(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 ProcessUpEvent(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::PointerPoint^>(info[0]))
      {
        try
        {
          ::Windows::UI::Input::PointerPoint^ arg0 = UnwrapPointerPoint(info[0]);
          
          wrapper->_instance->ProcessUpEvent(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 ProcessMouseWheelEvent(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::PointerPoint^>(info[0])
        && info[1]->IsBoolean()
        && info[2]->IsBoolean())
      {
        try
        {
          ::Windows::UI::Input::PointerPoint^ arg0 = UnwrapPointerPoint(info[0]);
          bool arg1 = Nan::To<bool>(info[1]).FromMaybe(false);
          bool arg2 = Nan::To<bool>(info[2]).FromMaybe(false);
          
          wrapper->_instance->ProcessMouseWheelEvent(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 ProcessInertia(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->ProcessInertia();
          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 CompleteGesture(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->CompleteGesture();
          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 ShowGestureFeedbackGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

      try  {
        bool result = wrapper->_instance->ShowGestureFeedback;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ShowGestureFeedbackSetter(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::Input::GestureRecognizer^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

      try  {
        float result = wrapper->_instance->PivotRadius;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PivotRadiusSetter(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::Input::GestureRecognizer^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

      try  {
        ::Windows::Foundation::Point result = wrapper->_instance->PivotCenter;
        info.GetReturnValue().Set(NodeRT::Utils::PointToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PivotCenterSetter(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::Input::GestureRecognizer^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Foundation::Point winRtValue = NodeRT::Utils::PointFromJs(value);

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

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

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

      try  {
        bool result = wrapper->_instance->ManipulationExact;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ManipulationExactSetter(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::Input::GestureRecognizer^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

      try  {
        float result = wrapper->_instance->InertiaTranslationDisplacement;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void InertiaTranslationDisplacementSetter(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::Input::GestureRecognizer^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

      try  {
        float result = wrapper->_instance->InertiaTranslationDeceleration;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void InertiaTranslationDecelerationSetter(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::Input::GestureRecognizer^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

      try  {
        float result = wrapper->_instance->InertiaRotationDeceleration;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void InertiaRotationDecelerationSetter(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::Input::GestureRecognizer^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

      try  {
        float result = wrapper->_instance->InertiaRotationAngle;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void InertiaRotationAngleSetter(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::Input::GestureRecognizer^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

      try  {
        float result = wrapper->_instance->InertiaExpansionDeceleration;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void InertiaExpansionDecelerationSetter(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::Input::GestureRecognizer^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

      try  {
        float result = wrapper->_instance->InertiaExpansion;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void InertiaExpansionSetter(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::Input::GestureRecognizer^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

      try  {
        ::Windows::UI::Input::GestureSettings result = wrapper->_instance->GestureSettings;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void GestureSettingsSetter(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::Input::GestureRecognizer^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

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

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

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

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

      try {

        ::Windows::UI::Input::CrossSlideThresholds winRtValue = CrossSlideThresholdsFromJsObject(value);

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

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

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

      try  {
        bool result = wrapper->_instance->CrossSlideHorizontally;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CrossSlideHorizontallySetter(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::Input::GestureRecognizer^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

      try  {
        bool result = wrapper->_instance->CrossSlideExact;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CrossSlideExactSetter(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::Input::GestureRecognizer^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

      try  {
        bool result = wrapper->_instance->AutoProcessInertia;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AutoProcessInertiaSetter(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::Input::GestureRecognizer^>(info.This())) {
        return;
      }

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

      try {

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

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

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

      GestureRecognizer *wrapper = GestureRecognizer::Unwrap<GestureRecognizer>(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 IsInertialGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

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

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

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

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

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

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

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

      try {

        unsigned int winRtValue = static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));

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

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

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

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

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

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

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

      try {

        unsigned int winRtValue = static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));

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

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

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

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

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

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

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

      try {

        unsigned int winRtValue = static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));

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

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

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

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

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

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

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

      try {

        unsigned int winRtValue = static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));

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

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

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

      try  {
        ::Windows::Foundation::TimeSpan result = wrapper->_instance->HoldStartDelay;
        info.GetReturnValue().Set(Nan::New<Number>(result.Duration/10000.0));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void HoldStartDelaySetter(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::Input::GestureRecognizer^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

      try  {
        float result = wrapper->_instance->HoldRadius;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void HoldRadiusSetter(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::Input::GestureRecognizer^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

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

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

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

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

      try {

        unsigned int winRtValue = static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));

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

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

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

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

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

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

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

      try {

        unsigned int winRtValue = static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));

        wrapper->_instance->HoldMaxContactCount = 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"crossSliding", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::GestureRecognizer^>(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;
        }
        GestureRecognizer *wrapper = GestureRecognizer::Unwrap<GestureRecognizer>(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->CrossSliding::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::GestureRecognizer^, ::Windows::UI::Input::CrossSlidingEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::GestureRecognizer^ arg0, ::Windows::UI::Input::CrossSlidingEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapGestureRecognizer(arg0);
                  wrappedArg1 = WrapCrossSlidingEventArgs(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"dragging", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::GestureRecognizer^>(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;
        }
        GestureRecognizer *wrapper = GestureRecognizer::Unwrap<GestureRecognizer>(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->Dragging::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::GestureRecognizer^, ::Windows::UI::Input::DraggingEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::GestureRecognizer^ arg0, ::Windows::UI::Input::DraggingEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapGestureRecognizer(arg0);
                  wrappedArg1 = WrapDraggingEventArgs(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::Input::GestureRecognizer^>(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;
        }
        GestureRecognizer *wrapper = GestureRecognizer::Unwrap<GestureRecognizer>(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::Foundation::TypedEventHandler<::Windows::UI::Input::GestureRecognizer^, ::Windows::UI::Input::HoldingEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::GestureRecognizer^ arg0, ::Windows::UI::Input::HoldingEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapGestureRecognizer(arg0);
                  wrappedArg1 = WrapHoldingEventArgs(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::Input::GestureRecognizer^>(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;
        }
        GestureRecognizer *wrapper = GestureRecognizer::Unwrap<GestureRecognizer>(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::Foundation::TypedEventHandler<::Windows::UI::Input::GestureRecognizer^, ::Windows::UI::Input::ManipulationCompletedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::GestureRecognizer^ arg0, ::Windows::UI::Input::ManipulationCompletedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapGestureRecognizer(arg0);
                  wrappedArg1 = WrapManipulationCompletedEventArgs(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::Input::GestureRecognizer^>(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;
        }
        GestureRecognizer *wrapper = GestureRecognizer::Unwrap<GestureRecognizer>(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::Foundation::TypedEventHandler<::Windows::UI::Input::GestureRecognizer^, ::Windows::UI::Input::ManipulationInertiaStartingEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::GestureRecognizer^ arg0, ::Windows::UI::Input::ManipulationInertiaStartingEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapGestureRecognizer(arg0);
                  wrappedArg1 = WrapManipulationInertiaStartingEventArgs(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::Input::GestureRecognizer^>(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;
        }
        GestureRecognizer *wrapper = GestureRecognizer::Unwrap<GestureRecognizer>(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::Foundation::TypedEventHandler<::Windows::UI::Input::GestureRecognizer^, ::Windows::UI::Input::ManipulationStartedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::GestureRecognizer^ arg0, ::Windows::UI::Input::ManipulationStartedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapGestureRecognizer(arg0);
                  wrappedArg1 = WrapManipulationStartedEventArgs(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"manipulationUpdated", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::GestureRecognizer^>(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;
        }
        GestureRecognizer *wrapper = GestureRecognizer::Unwrap<GestureRecognizer>(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->ManipulationUpdated::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::GestureRecognizer^, ::Windows::UI::Input::ManipulationUpdatedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::GestureRecognizer^ arg0, ::Windows::UI::Input::ManipulationUpdatedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapGestureRecognizer(arg0);
                  wrappedArg1 = WrapManipulationUpdatedEventArgs(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::Input::GestureRecognizer^>(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;
        }
        GestureRecognizer *wrapper = GestureRecognizer::Unwrap<GestureRecognizer>(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::Foundation::TypedEventHandler<::Windows::UI::Input::GestureRecognizer^, ::Windows::UI::Input::RightTappedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::GestureRecognizer^ arg0, ::Windows::UI::Input::RightTappedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapGestureRecognizer(arg0);
                  wrappedArg1 = WrapRightTappedEventArgs(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::Input::GestureRecognizer^>(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;
        }
        GestureRecognizer *wrapper = GestureRecognizer::Unwrap<GestureRecognizer>(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::Foundation::TypedEventHandler<::Windows::UI::Input::GestureRecognizer^, ::Windows::UI::Input::TappedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::GestureRecognizer^ arg0, ::Windows::UI::Input::TappedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapGestureRecognizer(arg0);
                  wrappedArg1 = WrapTappedEventArgs(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"crossSliding", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"dragging", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"holding", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"manipulationCompleted", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"manipulationInertiaStarting", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"manipulationStarted", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"manipulationUpdated", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"rightTapped", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"tapped", 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"crossSliding", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::GestureRecognizer^>(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;
          }
          GestureRecognizer *wrapper = GestureRecognizer::Unwrap<GestureRecognizer>(info.This());
          wrapper->_instance->CrossSliding::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"dragging", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::GestureRecognizer^>(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;
          }
          GestureRecognizer *wrapper = GestureRecognizer::Unwrap<GestureRecognizer>(info.This());
          wrapper->_instance->Dragging::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"holding", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::GestureRecognizer^>(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;
          }
          GestureRecognizer *wrapper = GestureRecognizer::Unwrap<GestureRecognizer>(info.This());
          wrapper->_instance->Holding::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"manipulationCompleted", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::GestureRecognizer^>(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;
          }
          GestureRecognizer *wrapper = GestureRecognizer::Unwrap<GestureRecognizer>(info.This());
          wrapper->_instance->ManipulationCompleted::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"manipulationInertiaStarting", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::GestureRecognizer^>(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;
          }
          GestureRecognizer *wrapper = GestureRecognizer::Unwrap<GestureRecognizer>(info.This());
          wrapper->_instance->ManipulationInertiaStarting::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"manipulationStarted", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::GestureRecognizer^>(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;
          }
          GestureRecognizer *wrapper = GestureRecognizer::Unwrap<GestureRecognizer>(info.This());
          wrapper->_instance->ManipulationStarted::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"manipulationUpdated", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::GestureRecognizer^>(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;
          }
          GestureRecognizer *wrapper = GestureRecognizer::Unwrap<GestureRecognizer>(info.This());
          wrapper->_instance->ManipulationUpdated::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"rightTapped", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::GestureRecognizer^>(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;
          }
          GestureRecognizer *wrapper = GestureRecognizer::Unwrap<GestureRecognizer>(info.This());
          wrapper->_instance->RightTapped::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"tapped", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::GestureRecognizer^>(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;
          }
          GestureRecognizer *wrapper = GestureRecognizer::Unwrap<GestureRecognizer>(info.This());
          wrapper->_instance->Tapped::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::Input::GestureRecognizer^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapGestureRecognizer(::Windows::UI::Input::GestureRecognizer^ wintRtInstance);
      friend ::Windows::UI::Input::GestureRecognizer^ UnwrapGestureRecognizer(Local<Value> value);
  };

  Persistent<FunctionTemplate> GestureRecognizer::s_constructorTemplate;

  v8::Local<v8::Value> WrapGestureRecognizer(::Windows::UI::Input::GestureRecognizer^ 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>(GestureRecognizer::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::GestureRecognizer^ UnwrapGestureRecognizer(Local<Value> value) {
     return GestureRecognizer::Unwrap<GestureRecognizer>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitGestureRecognizer(Local<Object> exports) {
    GestureRecognizer::Init(exports);
  }

  class HoldingEventArgs : 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>("HoldingEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("holdingState").ToLocalChecked(), HoldingStateGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pointerDeviceType").ToLocalChecked(), PointerDeviceTypeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("position").ToLocalChecked(), PositionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("contactCount").ToLocalChecked(), ContactCountGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("currentContactCount").ToLocalChecked(), CurrentContactCountGetter);

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



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

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

    private:

      HoldingEventArgs(::Windows::UI::Input::HoldingEventArgs^ 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::Input::HoldingEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::HoldingEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::HoldingEventArgs^) 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());

      HoldingEventArgs *wrapperInstance = new HoldingEventArgs(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::Input::HoldingEventArgs^>(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::Input::HoldingEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::HoldingEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try  {
        unsigned int result = wrapper->_instance->CurrentContactCount;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::HoldingEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapHoldingEventArgs(::Windows::UI::Input::HoldingEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::HoldingEventArgs^ UnwrapHoldingEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> HoldingEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapHoldingEventArgs(::Windows::UI::Input::HoldingEventArgs^ 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>(HoldingEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::HoldingEventArgs^ UnwrapHoldingEventArgs(Local<Value> value) {
     return HoldingEventArgs::Unwrap<HoldingEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitHoldingEventArgs(Local<Object> exports) {
    HoldingEventArgs::Init(exports);
  }

  class IPointerPointTransform : 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>("IPointerPointTransform").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "tryTransform", TryTransform);
            Nan::SetPrototypeMethod(localRef, "transformBounds", TransformBounds);
          



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

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



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

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

    private:

      IPointerPointTransform(::Windows::UI::Input::IPointerPointTransform^ 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::Input::IPointerPointTransform^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::IPointerPointTransform^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::IPointerPointTransform^) 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());

      IPointerPointTransform *wrapperInstance = new IPointerPointTransform(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::Input::IPointerPointTransform^>(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::Input::IPointerPointTransform^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::IPointerPointTransform^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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


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

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsPoint(info[0]))
      {
        try
        {
          ::Windows::Foundation::Point arg0 = NodeRT::Utils::PointFromJs(info[0]);
          ::Windows::Foundation::Point arg1;
          
          bool result;
          result = wrapper->_instance->TryTransform(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>("outPoint").ToLocalChecked(), NodeRT::Utils::PointToJs(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 TransformBounds(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsRect(info[0]))
      {
        try
        {
          ::Windows::Foundation::Rect arg0 = NodeRT::Utils::RectFromJs(info[0]);
          
          ::Windows::Foundation::Rect result;
          result = wrapper->_instance->TransformBounds(arg0);
          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 InverseGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

      try  {
        ::Windows::UI::Input::IPointerPointTransform^ result = wrapper->_instance->Inverse;
        info.GetReturnValue().Set(WrapIPointerPointTransform(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::IPointerPointTransform^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIPointerPointTransform(::Windows::UI::Input::IPointerPointTransform^ wintRtInstance);
      friend ::Windows::UI::Input::IPointerPointTransform^ UnwrapIPointerPointTransform(Local<Value> value);
  };

  Persistent<FunctionTemplate> IPointerPointTransform::s_constructorTemplate;

  v8::Local<v8::Value> WrapIPointerPointTransform(::Windows::UI::Input::IPointerPointTransform^ 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>(IPointerPointTransform::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::IPointerPointTransform^ UnwrapIPointerPointTransform(Local<Value> value) {
     return IPointerPointTransform::Unwrap<IPointerPointTransform>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIPointerPointTransform(Local<Object> exports) {
    IPointerPointTransform::Init(exports);
  }

  class InputActivationListener : 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>("InputActivationListener").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>("state").ToLocalChecked(), StateGetter);

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



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

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

    private:

      InputActivationListener(::Windows::UI::Input::InputActivationListener^ 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::Input::InputActivationListener^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::InputActivationListener^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::InputActivationListener^) 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());

      InputActivationListener *wrapperInstance = new InputActivationListener(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::Input::InputActivationListener^>(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::Input::InputActivationListener^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::InputActivationListener^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

      try  {
        ::Windows::UI::Input::InputActivationState result = wrapper->_instance->State;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(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"inputActivationChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::InputActivationListener^>(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;
        }
        InputActivationListener *wrapper = InputActivationListener::Unwrap<InputActivationListener>(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->InputActivationChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::InputActivationListener^, ::Windows::UI::Input::InputActivationListenerActivationChangedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::InputActivationListener^ arg0, ::Windows::UI::Input::InputActivationListenerActivationChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapInputActivationListener(arg0);
                  wrappedArg1 = WrapInputActivationListenerActivationChangedEventArgs(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"inputActivationChanged", 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"inputActivationChanged", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::InputActivationListener^>(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;
          }
          InputActivationListener *wrapper = InputActivationListener::Unwrap<InputActivationListener>(info.This());
          wrapper->_instance->InputActivationChanged::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::Input::InputActivationListener^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInputActivationListener(::Windows::UI::Input::InputActivationListener^ wintRtInstance);
      friend ::Windows::UI::Input::InputActivationListener^ UnwrapInputActivationListener(Local<Value> value);
  };

  Persistent<FunctionTemplate> InputActivationListener::s_constructorTemplate;

  v8::Local<v8::Value> WrapInputActivationListener(::Windows::UI::Input::InputActivationListener^ 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>(InputActivationListener::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::InputActivationListener^ UnwrapInputActivationListener(Local<Value> value) {
     return InputActivationListener::Unwrap<InputActivationListener>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInputActivationListener(Local<Object> exports) {
    InputActivationListener::Init(exports);
  }

  class InputActivationListenerActivationChangedEventArgs : 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>("InputActivationListenerActivationChangedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





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

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



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

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

    private:

      InputActivationListenerActivationChangedEventArgs(::Windows::UI::Input::InputActivationListenerActivationChangedEventArgs^ 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::Input::InputActivationListenerActivationChangedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::InputActivationListenerActivationChangedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::InputActivationListenerActivationChangedEventArgs^) 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());

      InputActivationListenerActivationChangedEventArgs *wrapperInstance = new InputActivationListenerActivationChangedEventArgs(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::Input::InputActivationListenerActivationChangedEventArgs^>(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::Input::InputActivationListenerActivationChangedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::InputActivationListenerActivationChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

      try  {
        ::Windows::UI::Input::InputActivationState result = wrapper->_instance->State;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::InputActivationListenerActivationChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInputActivationListenerActivationChangedEventArgs(::Windows::UI::Input::InputActivationListenerActivationChangedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::InputActivationListenerActivationChangedEventArgs^ UnwrapInputActivationListenerActivationChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> InputActivationListenerActivationChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapInputActivationListenerActivationChangedEventArgs(::Windows::UI::Input::InputActivationListenerActivationChangedEventArgs^ 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>(InputActivationListenerActivationChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::InputActivationListenerActivationChangedEventArgs^ UnwrapInputActivationListenerActivationChangedEventArgs(Local<Value> value) {
     return InputActivationListenerActivationChangedEventArgs::Unwrap<InputActivationListenerActivationChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInputActivationListenerActivationChangedEventArgs(Local<Object> exports) {
    InputActivationListenerActivationChangedEventArgs::Init(exports);
  }

  class KeyboardDeliveryInterceptor : 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>("KeyboardDeliveryInterceptor").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>("isInterceptionEnabledWhenInForeground").ToLocalChecked(), IsInterceptionEnabledWhenInForegroundGetter, IsInterceptionEnabledWhenInForegroundSetter);

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

        Nan::SetMethod(constructor, "getForCurrentView", GetForCurrentView);


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

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

    private:

      KeyboardDeliveryInterceptor(::Windows::UI::Input::KeyboardDeliveryInterceptor^ 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::Input::KeyboardDeliveryInterceptor^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::KeyboardDeliveryInterceptor^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::KeyboardDeliveryInterceptor^) 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());

      KeyboardDeliveryInterceptor *wrapperInstance = new KeyboardDeliveryInterceptor(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::Input::KeyboardDeliveryInterceptor^>(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::Input::KeyboardDeliveryInterceptor^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::KeyboardDeliveryInterceptor^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::UI::Input::KeyboardDeliveryInterceptor^ result;
          result = ::Windows::UI::Input::KeyboardDeliveryInterceptor::GetForCurrentView();
          info.GetReturnValue().Set(WrapKeyboardDeliveryInterceptor(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 IsInterceptionEnabledWhenInForegroundGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

      try  {
        bool result = wrapper->_instance->IsInterceptionEnabledWhenInForeground;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsInterceptionEnabledWhenInForegroundSetter(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::Input::KeyboardDeliveryInterceptor^>(info.This())) {
        return;
      }

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

      try {

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

        wrapper->_instance->IsInterceptionEnabledWhenInForeground = 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"keyDown", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::KeyboardDeliveryInterceptor^>(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;
        }
        KeyboardDeliveryInterceptor *wrapper = KeyboardDeliveryInterceptor::Unwrap<KeyboardDeliveryInterceptor>(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::Foundation::TypedEventHandler<::Windows::UI::Input::KeyboardDeliveryInterceptor^, ::Windows::UI::Core::KeyEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::KeyboardDeliveryInterceptor^ arg0, ::Windows::UI::Core::KeyEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapKeyboardDeliveryInterceptor(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "KeyEventArgs", 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::Input::KeyboardDeliveryInterceptor^>(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;
        }
        KeyboardDeliveryInterceptor *wrapper = KeyboardDeliveryInterceptor::Unwrap<KeyboardDeliveryInterceptor>(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::Foundation::TypedEventHandler<::Windows::UI::Input::KeyboardDeliveryInterceptor^, ::Windows::UI::Core::KeyEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::KeyboardDeliveryInterceptor^ arg0, ::Windows::UI::Core::KeyEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapKeyboardDeliveryInterceptor(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "KeyEventArgs", 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"keyDown", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"keyUp", 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"keyDown", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::KeyboardDeliveryInterceptor^>(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;
          }
          KeyboardDeliveryInterceptor *wrapper = KeyboardDeliveryInterceptor::Unwrap<KeyboardDeliveryInterceptor>(info.This());
          wrapper->_instance->KeyDown::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"keyUp", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::KeyboardDeliveryInterceptor^>(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;
          }
          KeyboardDeliveryInterceptor *wrapper = KeyboardDeliveryInterceptor::Unwrap<KeyboardDeliveryInterceptor>(info.This());
          wrapper->_instance->KeyUp::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::Input::KeyboardDeliveryInterceptor^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapKeyboardDeliveryInterceptor(::Windows::UI::Input::KeyboardDeliveryInterceptor^ wintRtInstance);
      friend ::Windows::UI::Input::KeyboardDeliveryInterceptor^ UnwrapKeyboardDeliveryInterceptor(Local<Value> value);
  };

  Persistent<FunctionTemplate> KeyboardDeliveryInterceptor::s_constructorTemplate;

  v8::Local<v8::Value> WrapKeyboardDeliveryInterceptor(::Windows::UI::Input::KeyboardDeliveryInterceptor^ 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>(KeyboardDeliveryInterceptor::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::KeyboardDeliveryInterceptor^ UnwrapKeyboardDeliveryInterceptor(Local<Value> value) {
     return KeyboardDeliveryInterceptor::Unwrap<KeyboardDeliveryInterceptor>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitKeyboardDeliveryInterceptor(Local<Object> exports) {
    KeyboardDeliveryInterceptor::Init(exports);
  }

  class ManipulationCompletedEventArgs : 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>("ManipulationCompletedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("cumulative").ToLocalChecked(), CumulativeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pointerDeviceType").ToLocalChecked(), PointerDeviceTypeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("position").ToLocalChecked(), PositionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("velocities").ToLocalChecked(), VelocitiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("contactCount").ToLocalChecked(), ContactCountGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("currentContactCount").ToLocalChecked(), CurrentContactCountGetter);

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



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

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

    private:

      ManipulationCompletedEventArgs(::Windows::UI::Input::ManipulationCompletedEventArgs^ 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::Input::ManipulationCompletedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::ManipulationCompletedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::ManipulationCompletedEventArgs^) 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());

      ManipulationCompletedEventArgs *wrapperInstance = new ManipulationCompletedEventArgs(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::Input::ManipulationCompletedEventArgs^>(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::Input::ManipulationCompletedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::ManipulationCompletedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try  {
        unsigned int result = wrapper->_instance->CurrentContactCount;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::ManipulationCompletedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapManipulationCompletedEventArgs(::Windows::UI::Input::ManipulationCompletedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::ManipulationCompletedEventArgs^ UnwrapManipulationCompletedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> ManipulationCompletedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapManipulationCompletedEventArgs(::Windows::UI::Input::ManipulationCompletedEventArgs^ 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>(ManipulationCompletedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::ManipulationCompletedEventArgs^ UnwrapManipulationCompletedEventArgs(Local<Value> value) {
     return ManipulationCompletedEventArgs::Unwrap<ManipulationCompletedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitManipulationCompletedEventArgs(Local<Object> exports) {
    ManipulationCompletedEventArgs::Init(exports);
  }

  class ManipulationInertiaStartingEventArgs : 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>("ManipulationInertiaStartingEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("cumulative").ToLocalChecked(), CumulativeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("delta").ToLocalChecked(), DeltaGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pointerDeviceType").ToLocalChecked(), PointerDeviceTypeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("position").ToLocalChecked(), PositionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("velocities").ToLocalChecked(), VelocitiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("contactCount").ToLocalChecked(), ContactCountGetter);

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



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

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

    private:

      ManipulationInertiaStartingEventArgs(::Windows::UI::Input::ManipulationInertiaStartingEventArgs^ 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::Input::ManipulationInertiaStartingEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::ManipulationInertiaStartingEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::ManipulationInertiaStartingEventArgs^) 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());

      ManipulationInertiaStartingEventArgs *wrapperInstance = new ManipulationInertiaStartingEventArgs(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::Input::ManipulationInertiaStartingEventArgs^>(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::Input::ManipulationInertiaStartingEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::ManipulationInertiaStartingEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try  {
        unsigned int result = wrapper->_instance->ContactCount;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::ManipulationInertiaStartingEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapManipulationInertiaStartingEventArgs(::Windows::UI::Input::ManipulationInertiaStartingEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::ManipulationInertiaStartingEventArgs^ UnwrapManipulationInertiaStartingEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> ManipulationInertiaStartingEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapManipulationInertiaStartingEventArgs(::Windows::UI::Input::ManipulationInertiaStartingEventArgs^ 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>(ManipulationInertiaStartingEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::ManipulationInertiaStartingEventArgs^ UnwrapManipulationInertiaStartingEventArgs(Local<Value> value) {
     return ManipulationInertiaStartingEventArgs::Unwrap<ManipulationInertiaStartingEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitManipulationInertiaStartingEventArgs(Local<Object> exports) {
    ManipulationInertiaStartingEventArgs::Init(exports);
  }

  class ManipulationStartedEventArgs : 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>("ManipulationStartedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("cumulative").ToLocalChecked(), CumulativeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pointerDeviceType").ToLocalChecked(), PointerDeviceTypeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("position").ToLocalChecked(), PositionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("contactCount").ToLocalChecked(), ContactCountGetter);

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



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

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

    private:

      ManipulationStartedEventArgs(::Windows::UI::Input::ManipulationStartedEventArgs^ 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::Input::ManipulationStartedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::ManipulationStartedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::ManipulationStartedEventArgs^) 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());

      ManipulationStartedEventArgs *wrapperInstance = new ManipulationStartedEventArgs(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::Input::ManipulationStartedEventArgs^>(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::Input::ManipulationStartedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::ManipulationStartedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

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

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

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

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

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

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

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

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

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

      try  {
        unsigned int result = wrapper->_instance->ContactCount;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::ManipulationStartedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapManipulationStartedEventArgs(::Windows::UI::Input::ManipulationStartedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::ManipulationStartedEventArgs^ UnwrapManipulationStartedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> ManipulationStartedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapManipulationStartedEventArgs(::Windows::UI::Input::ManipulationStartedEventArgs^ 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>(ManipulationStartedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::ManipulationStartedEventArgs^ UnwrapManipulationStartedEventArgs(Local<Value> value) {
     return ManipulationStartedEventArgs::Unwrap<ManipulationStartedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitManipulationStartedEventArgs(Local<Object> exports) {
    ManipulationStartedEventArgs::Init(exports);
  }

  class ManipulationUpdatedEventArgs : 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>("ManipulationUpdatedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("cumulative").ToLocalChecked(), CumulativeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("delta").ToLocalChecked(), DeltaGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pointerDeviceType").ToLocalChecked(), PointerDeviceTypeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("position").ToLocalChecked(), PositionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("velocities").ToLocalChecked(), VelocitiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("contactCount").ToLocalChecked(), ContactCountGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("currentContactCount").ToLocalChecked(), CurrentContactCountGetter);

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



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

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

    private:

      ManipulationUpdatedEventArgs(::Windows::UI::Input::ManipulationUpdatedEventArgs^ 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::Input::ManipulationUpdatedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::ManipulationUpdatedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::ManipulationUpdatedEventArgs^) 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());

      ManipulationUpdatedEventArgs *wrapperInstance = new ManipulationUpdatedEventArgs(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::Input::ManipulationUpdatedEventArgs^>(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::Input::ManipulationUpdatedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::ManipulationUpdatedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try  {
        unsigned int result = wrapper->_instance->CurrentContactCount;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::ManipulationUpdatedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapManipulationUpdatedEventArgs(::Windows::UI::Input::ManipulationUpdatedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::ManipulationUpdatedEventArgs^ UnwrapManipulationUpdatedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> ManipulationUpdatedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapManipulationUpdatedEventArgs(::Windows::UI::Input::ManipulationUpdatedEventArgs^ 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>(ManipulationUpdatedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::ManipulationUpdatedEventArgs^ UnwrapManipulationUpdatedEventArgs(Local<Value> value) {
     return ManipulationUpdatedEventArgs::Unwrap<ManipulationUpdatedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitManipulationUpdatedEventArgs(Local<Object> exports) {
    ManipulationUpdatedEventArgs::Init(exports);
  }

  class MouseWheelParameters : 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>("MouseWheelParameters").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pageTranslation").ToLocalChecked(), PageTranslationGetter, PageTranslationSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("deltaScale").ToLocalChecked(), DeltaScaleGetter, DeltaScaleSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("deltaRotationAngle").ToLocalChecked(), DeltaRotationAngleGetter, DeltaRotationAngleSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("charTranslation").ToLocalChecked(), CharTranslationGetter, CharTranslationSetter);

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



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

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

    private:

      MouseWheelParameters(::Windows::UI::Input::MouseWheelParameters^ 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::Input::MouseWheelParameters^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::MouseWheelParameters^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::MouseWheelParameters^) 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());

      MouseWheelParameters *wrapperInstance = new MouseWheelParameters(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::Input::MouseWheelParameters^>(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::Input::MouseWheelParameters^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::MouseWheelParameters^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

      try  {
        ::Windows::Foundation::Point result = wrapper->_instance->PageTranslation;
        info.GetReturnValue().Set(NodeRT::Utils::PointToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PageTranslationSetter(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::Input::MouseWheelParameters^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Foundation::Point winRtValue = NodeRT::Utils::PointFromJs(value);

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

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

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

      try  {
        float result = wrapper->_instance->DeltaScale;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DeltaScaleSetter(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::Input::MouseWheelParameters^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

      try  {
        float result = wrapper->_instance->DeltaRotationAngle;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DeltaRotationAngleSetter(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::Input::MouseWheelParameters^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

      try  {
        ::Windows::Foundation::Point result = wrapper->_instance->CharTranslation;
        info.GetReturnValue().Set(NodeRT::Utils::PointToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CharTranslationSetter(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::Input::MouseWheelParameters^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Foundation::Point winRtValue = NodeRT::Utils::PointFromJs(value);

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


    private:
      ::Windows::UI::Input::MouseWheelParameters^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMouseWheelParameters(::Windows::UI::Input::MouseWheelParameters^ wintRtInstance);
      friend ::Windows::UI::Input::MouseWheelParameters^ UnwrapMouseWheelParameters(Local<Value> value);
  };

  Persistent<FunctionTemplate> MouseWheelParameters::s_constructorTemplate;

  v8::Local<v8::Value> WrapMouseWheelParameters(::Windows::UI::Input::MouseWheelParameters^ 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>(MouseWheelParameters::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::MouseWheelParameters^ UnwrapMouseWheelParameters(Local<Value> value) {
     return MouseWheelParameters::Unwrap<MouseWheelParameters>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMouseWheelParameters(Local<Object> exports) {
    MouseWheelParameters::Init(exports);
  }

  class PointerPoint : 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>("PointerPoint").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("frameId").ToLocalChecked(), FrameIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isInContact").ToLocalChecked(), IsInContactGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pointerDevice").ToLocalChecked(), PointerDeviceGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pointerId").ToLocalChecked(), PointerIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("position").ToLocalChecked(), PositionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("properties").ToLocalChecked(), PropertiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("rawPosition").ToLocalChecked(), RawPositionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("timestamp").ToLocalChecked(), TimestampGetter);

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

        Nan::SetMethod(constructor, "getCurrentPoint", GetCurrentPoint);
        Nan::SetMethod(constructor, "getIntermediatePoints", GetIntermediatePoints);


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

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

    private:

      PointerPoint(::Windows::UI::Input::PointerPoint^ 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::Input::PointerPoint^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::PointerPoint^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::PointerPoint^) 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());

      PointerPoint *wrapperInstance = new PointerPoint(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::Input::PointerPoint^>(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::Input::PointerPoint^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::PointerPoint^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

      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::Input::PointerPoint^ result;
          result = ::Windows::UI::Input::PointerPoint::GetCurrentPoint(arg0);
          info.GetReturnValue().Set(WrapPointerPoint(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && info[0]->IsUint32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::IPointerPointTransform^>(info[1]))
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          ::Windows::UI::Input::IPointerPointTransform^ arg1 = UnwrapIPointerPointTransform(info[1]);
          
          ::Windows::UI::Input::PointerPoint^ result;
          result = ::Windows::UI::Input::PointerPoint::GetCurrentPoint(arg0, arg1);
          info.GetReturnValue().Set(WrapPointerPoint(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 GetIntermediatePoints(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && info[0]->IsUint32())
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          
          ::Windows::Foundation::Collections::IVector<::Windows::UI::Input::PointerPoint^>^ result;
          result = ::Windows::UI::Input::PointerPoint::GetIntermediatePoints(arg0);
          info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::UI::Input::PointerPoint^>::CreateVectorWrapper(result, 
            [](::Windows::UI::Input::PointerPoint^ val) -> Local<Value> {
              return WrapPointerPoint(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::PointerPoint^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::PointerPoint^ {
              return UnwrapPointerPoint(value);
            }
          ));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && info[0]->IsUint32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::IPointerPointTransform^>(info[1]))
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          ::Windows::UI::Input::IPointerPointTransform^ arg1 = UnwrapIPointerPointTransform(info[1]);
          
          ::Windows::Foundation::Collections::IVector<::Windows::UI::Input::PointerPoint^>^ result;
          result = ::Windows::UI::Input::PointerPoint::GetIntermediatePoints(arg0, arg1);
          info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::UI::Input::PointerPoint^>::CreateVectorWrapper(result, 
            [](::Windows::UI::Input::PointerPoint^ val) -> Local<Value> {
              return WrapPointerPoint(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::PointerPoint^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::PointerPoint^ {
              return UnwrapPointerPoint(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 FrameIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

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

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

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

      try  {
        ::Windows::Devices::Input::PointerDevice^ result = wrapper->_instance->PointerDevice;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Devices.Input", "PointerDevice", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PointerIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try  {
        unsigned __int64 result = wrapper->_instance->Timestamp;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::PointerPoint^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPointerPoint(::Windows::UI::Input::PointerPoint^ wintRtInstance);
      friend ::Windows::UI::Input::PointerPoint^ UnwrapPointerPoint(Local<Value> value);
  };

  Persistent<FunctionTemplate> PointerPoint::s_constructorTemplate;

  v8::Local<v8::Value> WrapPointerPoint(::Windows::UI::Input::PointerPoint^ 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>(PointerPoint::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::PointerPoint^ UnwrapPointerPoint(Local<Value> value) {
     return PointerPoint::Unwrap<PointerPoint>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPointerPoint(Local<Object> exports) {
    PointerPoint::Init(exports);
  }

  class PointerPointProperties : 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>("PointerPointProperties").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "hasUsage", HasUsage);
            Nan::SetPrototypeMethod(localRef, "getUsageValue", GetUsageValue);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("contactRect").ToLocalChecked(), ContactRectGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("contactRectRaw").ToLocalChecked(), ContactRectRawGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isBarrelButtonPressed").ToLocalChecked(), IsBarrelButtonPressedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isCanceled").ToLocalChecked(), IsCanceledGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isEraser").ToLocalChecked(), IsEraserGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isHorizontalMouseWheel").ToLocalChecked(), IsHorizontalMouseWheelGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isInRange").ToLocalChecked(), IsInRangeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isInverted").ToLocalChecked(), IsInvertedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isLeftButtonPressed").ToLocalChecked(), IsLeftButtonPressedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isMiddleButtonPressed").ToLocalChecked(), IsMiddleButtonPressedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isPrimary").ToLocalChecked(), IsPrimaryGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isRightButtonPressed").ToLocalChecked(), IsRightButtonPressedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isXButton1Pressed").ToLocalChecked(), IsXButton1PressedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isXButton2Pressed").ToLocalChecked(), IsXButton2PressedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("mouseWheelDelta").ToLocalChecked(), MouseWheelDeltaGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("orientation").ToLocalChecked(), OrientationGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pointerUpdateKind").ToLocalChecked(), PointerUpdateKindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pressure").ToLocalChecked(), PressureGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("touchConfidence").ToLocalChecked(), TouchConfidenceGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("twist").ToLocalChecked(), TwistGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("xTilt").ToLocalChecked(), XTiltGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("yTilt").ToLocalChecked(), YTiltGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("zDistance").ToLocalChecked(), ZDistanceGetter);

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



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

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

    private:

      PointerPointProperties(::Windows::UI::Input::PointerPointProperties^ 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::Input::PointerPointProperties^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::PointerPointProperties^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::PointerPointProperties^) 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());

      PointerPointProperties *wrapperInstance = new PointerPointProperties(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::Input::PointerPointProperties^>(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::Input::PointerPointProperties^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::PointerPointProperties^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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


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

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

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

      if (info.Length() == 2
        && info[0]->IsUint32()
        && info[1]->IsUint32())
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          unsigned int arg1 = static_cast<unsigned int>(Nan::To<uint32_t>(info[1]).FromMaybe(0));
          
          bool result;
          result = wrapper->_instance->HasUsage(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 GetUsageValue(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 2
        && info[0]->IsUint32()
        && info[1]->IsUint32())
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          unsigned int arg1 = static_cast<unsigned int>(Nan::To<uint32_t>(info[1]).FromMaybe(0));
          
          int result;
          result = wrapper->_instance->GetUsageValue(arg0, arg1);
          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;
      }
    }



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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try  {
        ::Platform::IBox<float>^ result = wrapper->_instance->ZDistance;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Number>(static_cast<double>(result->Value))) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::PointerPointProperties^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPointerPointProperties(::Windows::UI::Input::PointerPointProperties^ wintRtInstance);
      friend ::Windows::UI::Input::PointerPointProperties^ UnwrapPointerPointProperties(Local<Value> value);
  };

  Persistent<FunctionTemplate> PointerPointProperties::s_constructorTemplate;

  v8::Local<v8::Value> WrapPointerPointProperties(::Windows::UI::Input::PointerPointProperties^ 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>(PointerPointProperties::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::PointerPointProperties^ UnwrapPointerPointProperties(Local<Value> value) {
     return PointerPointProperties::Unwrap<PointerPointProperties>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPointerPointProperties(Local<Object> exports) {
    PointerPointProperties::Init(exports);
  }

  class PointerVisualizationSettings : 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>("PointerVisualizationSettings").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isContactFeedbackEnabled").ToLocalChecked(), IsContactFeedbackEnabledGetter, IsContactFeedbackEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isBarrelButtonFeedbackEnabled").ToLocalChecked(), IsBarrelButtonFeedbackEnabledGetter, IsBarrelButtonFeedbackEnabledSetter);

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

        Nan::SetMethod(constructor, "getForCurrentView", GetForCurrentView);


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

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

    private:

      PointerVisualizationSettings(::Windows::UI::Input::PointerVisualizationSettings^ 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::Input::PointerVisualizationSettings^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::PointerVisualizationSettings^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::PointerVisualizationSettings^) 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());

      PointerVisualizationSettings *wrapperInstance = new PointerVisualizationSettings(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::Input::PointerVisualizationSettings^>(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::Input::PointerVisualizationSettings^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::PointerVisualizationSettings^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::UI::Input::PointerVisualizationSettings^ result;
          result = ::Windows::UI::Input::PointerVisualizationSettings::GetForCurrentView();
          info.GetReturnValue().Set(WrapPointerVisualizationSettings(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 IsContactFeedbackEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

      try  {
        bool result = wrapper->_instance->IsContactFeedbackEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsContactFeedbackEnabledSetter(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::Input::PointerVisualizationSettings^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

      try  {
        bool result = wrapper->_instance->IsBarrelButtonFeedbackEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsBarrelButtonFeedbackEnabledSetter(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::Input::PointerVisualizationSettings^>(info.This())) {
        return;
      }

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

      try {

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

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


    private:
      ::Windows::UI::Input::PointerVisualizationSettings^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPointerVisualizationSettings(::Windows::UI::Input::PointerVisualizationSettings^ wintRtInstance);
      friend ::Windows::UI::Input::PointerVisualizationSettings^ UnwrapPointerVisualizationSettings(Local<Value> value);
  };

  Persistent<FunctionTemplate> PointerVisualizationSettings::s_constructorTemplate;

  v8::Local<v8::Value> WrapPointerVisualizationSettings(::Windows::UI::Input::PointerVisualizationSettings^ 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>(PointerVisualizationSettings::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::PointerVisualizationSettings^ UnwrapPointerVisualizationSettings(Local<Value> value) {
     return PointerVisualizationSettings::Unwrap<PointerVisualizationSettings>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPointerVisualizationSettings(Local<Object> exports) {
    PointerVisualizationSettings::Init(exports);
  }

  class RadialController : 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>("RadialController").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>("useAutomaticHapticFeedback").ToLocalChecked(), UseAutomaticHapticFeedbackGetter, UseAutomaticHapticFeedbackSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("rotationResolutionInDegrees").ToLocalChecked(), RotationResolutionInDegreesGetter, RotationResolutionInDegreesSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("menu").ToLocalChecked(), MenuGetter);

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

        Nan::SetMethod(constructor, "isSupported", IsSupported);
        Nan::SetMethod(constructor, "createForCurrentView", CreateForCurrentView);


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

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

    private:

      RadialController(::Windows::UI::Input::RadialController^ 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::Input::RadialController^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialController^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::RadialController^) 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());

      RadialController *wrapperInstance = new RadialController(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::Input::RadialController^>(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::Input::RadialController^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::RadialController^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

      if (info.Length() == 0)
      {
        try
        {
          bool result;
          result = ::Windows::UI::Input::RadialController::IsSupported();
          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 CreateForCurrentView(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::UI::Input::RadialController^ result;
          result = ::Windows::UI::Input::RadialController::CreateForCurrentView();
          info.GetReturnValue().Set(WrapRadialController(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 UseAutomaticHapticFeedbackGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

      try  {
        bool result = wrapper->_instance->UseAutomaticHapticFeedback;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void UseAutomaticHapticFeedbackSetter(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::Input::RadialController^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

      try  {
        double result = wrapper->_instance->RotationResolutionInDegrees;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RotationResolutionInDegreesSetter(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::Input::RadialController^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

      try  {
        ::Windows::UI::Input::RadialControllerMenu^ result = wrapper->_instance->Menu;
        info.GetReturnValue().Set(WrapRadialControllerMenu(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"buttonClicked", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialController^>(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;
        }
        RadialController *wrapper = RadialController::Unwrap<RadialController>(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->ButtonClicked::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::RadialController^, ::Windows::UI::Input::RadialControllerButtonClickedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::RadialController^ arg0, ::Windows::UI::Input::RadialControllerButtonClickedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapRadialController(arg0);
                  wrappedArg1 = WrapRadialControllerButtonClickedEventArgs(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"controlAcquired", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialController^>(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;
        }
        RadialController *wrapper = RadialController::Unwrap<RadialController>(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->ControlAcquired::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::RadialController^, ::Windows::UI::Input::RadialControllerControlAcquiredEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::RadialController^ arg0, ::Windows::UI::Input::RadialControllerControlAcquiredEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapRadialController(arg0);
                  wrappedArg1 = WrapRadialControllerControlAcquiredEventArgs(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"controlLost", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialController^>(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;
        }
        RadialController *wrapper = RadialController::Unwrap<RadialController>(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->ControlLost::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::RadialController^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::UI::Input::RadialController^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapRadialController(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"rotationChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialController^>(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;
        }
        RadialController *wrapper = RadialController::Unwrap<RadialController>(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->RotationChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::RadialController^, ::Windows::UI::Input::RadialControllerRotationChangedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::RadialController^ arg0, ::Windows::UI::Input::RadialControllerRotationChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapRadialController(arg0);
                  wrappedArg1 = WrapRadialControllerRotationChangedEventArgs(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"screenContactContinued", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialController^>(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;
        }
        RadialController *wrapper = RadialController::Unwrap<RadialController>(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->ScreenContactContinued::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::RadialController^, ::Windows::UI::Input::RadialControllerScreenContactContinuedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::RadialController^ arg0, ::Windows::UI::Input::RadialControllerScreenContactContinuedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapRadialController(arg0);
                  wrappedArg1 = WrapRadialControllerScreenContactContinuedEventArgs(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"screenContactEnded", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialController^>(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;
        }
        RadialController *wrapper = RadialController::Unwrap<RadialController>(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->ScreenContactEnded::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::RadialController^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::UI::Input::RadialController^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapRadialController(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"screenContactStarted", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialController^>(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;
        }
        RadialController *wrapper = RadialController::Unwrap<RadialController>(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->ScreenContactStarted::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::RadialController^, ::Windows::UI::Input::RadialControllerScreenContactStartedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::RadialController^ arg0, ::Windows::UI::Input::RadialControllerScreenContactStartedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapRadialController(arg0);
                  wrappedArg1 = WrapRadialControllerScreenContactStartedEventArgs(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"buttonHolding", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialController^>(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;
        }
        RadialController *wrapper = RadialController::Unwrap<RadialController>(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->ButtonHolding::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::RadialController^, ::Windows::UI::Input::RadialControllerButtonHoldingEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::RadialController^ arg0, ::Windows::UI::Input::RadialControllerButtonHoldingEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapRadialController(arg0);
                  wrappedArg1 = WrapRadialControllerButtonHoldingEventArgs(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"buttonPressed", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialController^>(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;
        }
        RadialController *wrapper = RadialController::Unwrap<RadialController>(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->ButtonPressed::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::RadialController^, ::Windows::UI::Input::RadialControllerButtonPressedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::RadialController^ arg0, ::Windows::UI::Input::RadialControllerButtonPressedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapRadialController(arg0);
                  wrappedArg1 = WrapRadialControllerButtonPressedEventArgs(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"buttonReleased", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialController^>(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;
        }
        RadialController *wrapper = RadialController::Unwrap<RadialController>(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->ButtonReleased::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::RadialController^, ::Windows::UI::Input::RadialControllerButtonReleasedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::RadialController^ arg0, ::Windows::UI::Input::RadialControllerButtonReleasedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapRadialController(arg0);
                  wrappedArg1 = WrapRadialControllerButtonReleasedEventArgs(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"buttonClicked", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"controlAcquired", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"controlLost", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"rotationChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"screenContactContinued", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"screenContactEnded", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"screenContactStarted", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"buttonHolding", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"buttonPressed", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"buttonReleased", 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"buttonClicked", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialController^>(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;
          }
          RadialController *wrapper = RadialController::Unwrap<RadialController>(info.This());
          wrapper->_instance->ButtonClicked::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"controlAcquired", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialController^>(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;
          }
          RadialController *wrapper = RadialController::Unwrap<RadialController>(info.This());
          wrapper->_instance->ControlAcquired::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"controlLost", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialController^>(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;
          }
          RadialController *wrapper = RadialController::Unwrap<RadialController>(info.This());
          wrapper->_instance->ControlLost::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"rotationChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialController^>(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;
          }
          RadialController *wrapper = RadialController::Unwrap<RadialController>(info.This());
          wrapper->_instance->RotationChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"screenContactContinued", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialController^>(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;
          }
          RadialController *wrapper = RadialController::Unwrap<RadialController>(info.This());
          wrapper->_instance->ScreenContactContinued::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"screenContactEnded", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialController^>(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;
          }
          RadialController *wrapper = RadialController::Unwrap<RadialController>(info.This());
          wrapper->_instance->ScreenContactEnded::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"screenContactStarted", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialController^>(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;
          }
          RadialController *wrapper = RadialController::Unwrap<RadialController>(info.This());
          wrapper->_instance->ScreenContactStarted::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"buttonHolding", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialController^>(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;
          }
          RadialController *wrapper = RadialController::Unwrap<RadialController>(info.This());
          wrapper->_instance->ButtonHolding::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"buttonPressed", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialController^>(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;
          }
          RadialController *wrapper = RadialController::Unwrap<RadialController>(info.This());
          wrapper->_instance->ButtonPressed::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"buttonReleased", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialController^>(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;
          }
          RadialController *wrapper = RadialController::Unwrap<RadialController>(info.This());
          wrapper->_instance->ButtonReleased::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::Input::RadialController^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapRadialController(::Windows::UI::Input::RadialController^ wintRtInstance);
      friend ::Windows::UI::Input::RadialController^ UnwrapRadialController(Local<Value> value);
  };

  Persistent<FunctionTemplate> RadialController::s_constructorTemplate;

  v8::Local<v8::Value> WrapRadialController(::Windows::UI::Input::RadialController^ 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>(RadialController::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::RadialController^ UnwrapRadialController(Local<Value> value) {
     return RadialController::Unwrap<RadialController>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitRadialController(Local<Object> exports) {
    RadialController::Init(exports);
  }

  class RadialControllerButtonClickedEventArgs : 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>("RadialControllerButtonClickedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("contact").ToLocalChecked(), ContactGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("simpleHapticsController").ToLocalChecked(), SimpleHapticsControllerGetter);

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



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

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

    private:

      RadialControllerButtonClickedEventArgs(::Windows::UI::Input::RadialControllerButtonClickedEventArgs^ 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::Input::RadialControllerButtonClickedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialControllerButtonClickedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::RadialControllerButtonClickedEventArgs^) 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());

      RadialControllerButtonClickedEventArgs *wrapperInstance = new RadialControllerButtonClickedEventArgs(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::Input::RadialControllerButtonClickedEventArgs^>(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::Input::RadialControllerButtonClickedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::RadialControllerButtonClickedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

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

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

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

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


    private:
      ::Windows::UI::Input::RadialControllerButtonClickedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapRadialControllerButtonClickedEventArgs(::Windows::UI::Input::RadialControllerButtonClickedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::RadialControllerButtonClickedEventArgs^ UnwrapRadialControllerButtonClickedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> RadialControllerButtonClickedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapRadialControllerButtonClickedEventArgs(::Windows::UI::Input::RadialControllerButtonClickedEventArgs^ 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>(RadialControllerButtonClickedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::RadialControllerButtonClickedEventArgs^ UnwrapRadialControllerButtonClickedEventArgs(Local<Value> value) {
     return RadialControllerButtonClickedEventArgs::Unwrap<RadialControllerButtonClickedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitRadialControllerButtonClickedEventArgs(Local<Object> exports) {
    RadialControllerButtonClickedEventArgs::Init(exports);
  }

  class RadialControllerButtonHoldingEventArgs : 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>("RadialControllerButtonHoldingEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("contact").ToLocalChecked(), ContactGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("simpleHapticsController").ToLocalChecked(), SimpleHapticsControllerGetter);

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



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

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

    private:

      RadialControllerButtonHoldingEventArgs(::Windows::UI::Input::RadialControllerButtonHoldingEventArgs^ 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::Input::RadialControllerButtonHoldingEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialControllerButtonHoldingEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::RadialControllerButtonHoldingEventArgs^) 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());

      RadialControllerButtonHoldingEventArgs *wrapperInstance = new RadialControllerButtonHoldingEventArgs(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::Input::RadialControllerButtonHoldingEventArgs^>(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::Input::RadialControllerButtonHoldingEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::RadialControllerButtonHoldingEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

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

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

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

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


    private:
      ::Windows::UI::Input::RadialControllerButtonHoldingEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapRadialControllerButtonHoldingEventArgs(::Windows::UI::Input::RadialControllerButtonHoldingEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::RadialControllerButtonHoldingEventArgs^ UnwrapRadialControllerButtonHoldingEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> RadialControllerButtonHoldingEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapRadialControllerButtonHoldingEventArgs(::Windows::UI::Input::RadialControllerButtonHoldingEventArgs^ 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>(RadialControllerButtonHoldingEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::RadialControllerButtonHoldingEventArgs^ UnwrapRadialControllerButtonHoldingEventArgs(Local<Value> value) {
     return RadialControllerButtonHoldingEventArgs::Unwrap<RadialControllerButtonHoldingEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitRadialControllerButtonHoldingEventArgs(Local<Object> exports) {
    RadialControllerButtonHoldingEventArgs::Init(exports);
  }

  class RadialControllerButtonPressedEventArgs : 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>("RadialControllerButtonPressedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("contact").ToLocalChecked(), ContactGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("simpleHapticsController").ToLocalChecked(), SimpleHapticsControllerGetter);

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



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

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

    private:

      RadialControllerButtonPressedEventArgs(::Windows::UI::Input::RadialControllerButtonPressedEventArgs^ 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::Input::RadialControllerButtonPressedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialControllerButtonPressedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::RadialControllerButtonPressedEventArgs^) 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());

      RadialControllerButtonPressedEventArgs *wrapperInstance = new RadialControllerButtonPressedEventArgs(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::Input::RadialControllerButtonPressedEventArgs^>(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::Input::RadialControllerButtonPressedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::RadialControllerButtonPressedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

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

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

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

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


    private:
      ::Windows::UI::Input::RadialControllerButtonPressedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapRadialControllerButtonPressedEventArgs(::Windows::UI::Input::RadialControllerButtonPressedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::RadialControllerButtonPressedEventArgs^ UnwrapRadialControllerButtonPressedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> RadialControllerButtonPressedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapRadialControllerButtonPressedEventArgs(::Windows::UI::Input::RadialControllerButtonPressedEventArgs^ 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>(RadialControllerButtonPressedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::RadialControllerButtonPressedEventArgs^ UnwrapRadialControllerButtonPressedEventArgs(Local<Value> value) {
     return RadialControllerButtonPressedEventArgs::Unwrap<RadialControllerButtonPressedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitRadialControllerButtonPressedEventArgs(Local<Object> exports) {
    RadialControllerButtonPressedEventArgs::Init(exports);
  }

  class RadialControllerButtonReleasedEventArgs : 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>("RadialControllerButtonReleasedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("contact").ToLocalChecked(), ContactGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("simpleHapticsController").ToLocalChecked(), SimpleHapticsControllerGetter);

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



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

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

    private:

      RadialControllerButtonReleasedEventArgs(::Windows::UI::Input::RadialControllerButtonReleasedEventArgs^ 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::Input::RadialControllerButtonReleasedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialControllerButtonReleasedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::RadialControllerButtonReleasedEventArgs^) 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());

      RadialControllerButtonReleasedEventArgs *wrapperInstance = new RadialControllerButtonReleasedEventArgs(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::Input::RadialControllerButtonReleasedEventArgs^>(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::Input::RadialControllerButtonReleasedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::RadialControllerButtonReleasedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

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

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

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

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


    private:
      ::Windows::UI::Input::RadialControllerButtonReleasedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapRadialControllerButtonReleasedEventArgs(::Windows::UI::Input::RadialControllerButtonReleasedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::RadialControllerButtonReleasedEventArgs^ UnwrapRadialControllerButtonReleasedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> RadialControllerButtonReleasedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapRadialControllerButtonReleasedEventArgs(::Windows::UI::Input::RadialControllerButtonReleasedEventArgs^ 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>(RadialControllerButtonReleasedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::RadialControllerButtonReleasedEventArgs^ UnwrapRadialControllerButtonReleasedEventArgs(Local<Value> value) {
     return RadialControllerButtonReleasedEventArgs::Unwrap<RadialControllerButtonReleasedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitRadialControllerButtonReleasedEventArgs(Local<Object> exports) {
    RadialControllerButtonReleasedEventArgs::Init(exports);
  }

  class RadialControllerConfiguration : 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>("RadialControllerConfiguration").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "setDefaultMenuItems", SetDefaultMenuItems);
            Nan::SetPrototypeMethod(localRef, "resetToDefaultMenuItems", ResetToDefaultMenuItems);
            Nan::SetPrototypeMethod(localRef, "trySelectDefaultMenuItem", TrySelectDefaultMenuItem);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isMenuSuppressed").ToLocalChecked(), IsMenuSuppressedGetter, IsMenuSuppressedSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("activeControllerWhenMenuIsSuppressed").ToLocalChecked(), ActiveControllerWhenMenuIsSuppressedGetter, ActiveControllerWhenMenuIsSuppressedSetter);

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

        Nan::SetMethod(constructor, "getForCurrentView", GetForCurrentView);
        Nan::SetAccessor(constructor, Nan::New<String>("isAppControllerEnabled").ToLocalChecked(), IsAppControllerEnabledGetter, IsAppControllerEnabledSetter);
        Nan::SetAccessor(constructor, Nan::New<String>("appController").ToLocalChecked(), AppControllerGetter, AppControllerSetter);


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

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

    private:

      RadialControllerConfiguration(::Windows::UI::Input::RadialControllerConfiguration^ 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::Input::RadialControllerConfiguration^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialControllerConfiguration^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::RadialControllerConfiguration^) 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());

      RadialControllerConfiguration *wrapperInstance = new RadialControllerConfiguration(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::Input::RadialControllerConfiguration^>(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::Input::RadialControllerConfiguration^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::RadialControllerConfiguration^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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


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

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

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

      if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Windows::UI::Input::RadialControllerSystemMenuItemKind>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<::Windows::UI::Input::RadialControllerSystemMenuItemKind>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Windows::UI::Input::RadialControllerSystemMenuItemKind>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::UI::Input::RadialControllerSystemMenuItemKind>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsInt32();
                 },
                 [](Local<Value> value) -> ::Windows::UI::Input::RadialControllerSystemMenuItemKind {
                   return static_cast<::Windows::UI::Input::RadialControllerSystemMenuItemKind>(Nan::To<int32_t>(value).FromMaybe(0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Windows::UI::Input::RadialControllerSystemMenuItemKind>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          wrapper->_instance->SetDefaultMenuItems(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 ResetToDefaultMenuItems(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->ResetToDefaultMenuItems();
          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 TrySelectDefaultMenuItem(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::UI::Input::RadialControllerSystemMenuItemKind arg0 = static_cast<::Windows::UI::Input::RadialControllerSystemMenuItemKind>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          bool result;
          result = wrapper->_instance->TrySelectDefaultMenuItem(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 GetForCurrentView(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::UI::Input::RadialControllerConfiguration^ result;
          result = ::Windows::UI::Input::RadialControllerConfiguration::GetForCurrentView();
          info.GetReturnValue().Set(WrapRadialControllerConfiguration(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 IsMenuSuppressedGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

      try  {
        bool result = wrapper->_instance->IsMenuSuppressed;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsMenuSuppressedSetter(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::Input::RadialControllerConfiguration^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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


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

      try
      {
        bool result = ::Windows::UI::Input::RadialControllerConfiguration::IsAppControllerEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void IsAppControllerEnabledSetter(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;
      }

      try {


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

        ::Windows::UI::Input::RadialControllerConfiguration::IsAppControllerEnabled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      

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

      try
      {
        ::Windows::UI::Input::RadialController^ result = ::Windows::UI::Input::RadialControllerConfiguration::AppController;
        info.GetReturnValue().Set(WrapRadialController(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

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

      try {


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

        ::Windows::UI::Input::RadialControllerConfiguration::AppController = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      

    private:
      ::Windows::UI::Input::RadialControllerConfiguration^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapRadialControllerConfiguration(::Windows::UI::Input::RadialControllerConfiguration^ wintRtInstance);
      friend ::Windows::UI::Input::RadialControllerConfiguration^ UnwrapRadialControllerConfiguration(Local<Value> value);
  };

  Persistent<FunctionTemplate> RadialControllerConfiguration::s_constructorTemplate;

  v8::Local<v8::Value> WrapRadialControllerConfiguration(::Windows::UI::Input::RadialControllerConfiguration^ 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>(RadialControllerConfiguration::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::RadialControllerConfiguration^ UnwrapRadialControllerConfiguration(Local<Value> value) {
     return RadialControllerConfiguration::Unwrap<RadialControllerConfiguration>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitRadialControllerConfiguration(Local<Object> exports) {
    RadialControllerConfiguration::Init(exports);
  }

  class RadialControllerControlAcquiredEventArgs : 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>("RadialControllerControlAcquiredEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("contact").ToLocalChecked(), ContactGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isButtonPressed").ToLocalChecked(), IsButtonPressedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("simpleHapticsController").ToLocalChecked(), SimpleHapticsControllerGetter);

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



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

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

    private:

      RadialControllerControlAcquiredEventArgs(::Windows::UI::Input::RadialControllerControlAcquiredEventArgs^ 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::Input::RadialControllerControlAcquiredEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialControllerControlAcquiredEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::RadialControllerControlAcquiredEventArgs^) 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());

      RadialControllerControlAcquiredEventArgs *wrapperInstance = new RadialControllerControlAcquiredEventArgs(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::Input::RadialControllerControlAcquiredEventArgs^>(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::Input::RadialControllerControlAcquiredEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::RadialControllerControlAcquiredEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

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

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

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

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

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

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

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


    private:
      ::Windows::UI::Input::RadialControllerControlAcquiredEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapRadialControllerControlAcquiredEventArgs(::Windows::UI::Input::RadialControllerControlAcquiredEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::RadialControllerControlAcquiredEventArgs^ UnwrapRadialControllerControlAcquiredEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> RadialControllerControlAcquiredEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapRadialControllerControlAcquiredEventArgs(::Windows::UI::Input::RadialControllerControlAcquiredEventArgs^ 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>(RadialControllerControlAcquiredEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::RadialControllerControlAcquiredEventArgs^ UnwrapRadialControllerControlAcquiredEventArgs(Local<Value> value) {
     return RadialControllerControlAcquiredEventArgs::Unwrap<RadialControllerControlAcquiredEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitRadialControllerControlAcquiredEventArgs(Local<Object> exports) {
    RadialControllerControlAcquiredEventArgs::Init(exports);
  }

  class RadialControllerMenu : 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>("RadialControllerMenu").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "getSelectedMenuItem", GetSelectedMenuItem);
            Nan::SetPrototypeMethod(localRef, "selectMenuItem", SelectMenuItem);
            Nan::SetPrototypeMethod(localRef, "trySelectPreviouslySelectedMenuItem", TrySelectPreviouslySelectedMenuItem);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isEnabled").ToLocalChecked(), IsEnabledGetter, IsEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("items").ToLocalChecked(), ItemsGetter);

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



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

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

    private:

      RadialControllerMenu(::Windows::UI::Input::RadialControllerMenu^ 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::Input::RadialControllerMenu^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialControllerMenu^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::RadialControllerMenu^) 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());

      RadialControllerMenu *wrapperInstance = new RadialControllerMenu(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::Input::RadialControllerMenu^>(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::Input::RadialControllerMenu^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::RadialControllerMenu^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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


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

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::UI::Input::RadialControllerMenuItem^ result;
          result = wrapper->_instance->GetSelectedMenuItem();
          info.GetReturnValue().Set(WrapRadialControllerMenuItem(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 SelectMenuItem(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialControllerMenuItem^>(info[0]))
      {
        try
        {
          ::Windows::UI::Input::RadialControllerMenuItem^ arg0 = UnwrapRadialControllerMenuItem(info[0]);
          
          wrapper->_instance->SelectMenuItem(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 TrySelectPreviouslySelectedMenuItem(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 0)
      {
        try
        {
          bool result;
          result = wrapper->_instance->TrySelectPreviouslySelectedMenuItem();
          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 IsEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

      RadialControllerMenu *wrapper = RadialControllerMenu::Unwrap<RadialControllerMenu>(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 IsEnabledSetter(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::Input::RadialControllerMenu^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::UI::Input::RadialControllerMenuItem^>^ result = wrapper->_instance->Items;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::UI::Input::RadialControllerMenuItem^>::CreateVectorWrapper(result, 
            [](::Windows::UI::Input::RadialControllerMenuItem^ val) -> Local<Value> {
              return WrapRadialControllerMenuItem(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialControllerMenuItem^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::RadialControllerMenuItem^ {
              return UnwrapRadialControllerMenuItem(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::RadialControllerMenu^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapRadialControllerMenu(::Windows::UI::Input::RadialControllerMenu^ wintRtInstance);
      friend ::Windows::UI::Input::RadialControllerMenu^ UnwrapRadialControllerMenu(Local<Value> value);
  };

  Persistent<FunctionTemplate> RadialControllerMenu::s_constructorTemplate;

  v8::Local<v8::Value> WrapRadialControllerMenu(::Windows::UI::Input::RadialControllerMenu^ 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>(RadialControllerMenu::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::RadialControllerMenu^ UnwrapRadialControllerMenu(Local<Value> value) {
     return RadialControllerMenu::Unwrap<RadialControllerMenu>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitRadialControllerMenu(Local<Object> exports) {
    RadialControllerMenu::Init(exports);
  }

  class RadialControllerMenuItem : 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>("RadialControllerMenuItem").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>("tag").ToLocalChecked(), TagGetter, TagSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("displayText").ToLocalChecked(), DisplayTextGetter);

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

        Nan::SetMethod(constructor, "createFromFontGlyph", CreateFromFontGlyph);
        Nan::SetMethod(constructor, "createFromIcon", CreateFromIcon);
        Nan::SetMethod(constructor, "createFromKnownIcon", CreateFromKnownIcon);


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

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

    private:

      RadialControllerMenuItem(::Windows::UI::Input::RadialControllerMenuItem^ 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::Input::RadialControllerMenuItem^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialControllerMenuItem^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::RadialControllerMenuItem^) 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());

      RadialControllerMenuItem *wrapperInstance = new RadialControllerMenuItem(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::Input::RadialControllerMenuItem^>(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::Input::RadialControllerMenuItem^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::RadialControllerMenuItem^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

      if (info.Length() == 3
        && info[0]->IsString()
        && info[1]->IsString()
        && info[2]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          Platform::String^ arg2 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[2])));
          
          ::Windows::UI::Input::RadialControllerMenuItem^ result;
          result = ::Windows::UI::Input::RadialControllerMenuItem::CreateFromFontGlyph(arg0, arg1, arg2);
          info.GetReturnValue().Set(WrapRadialControllerMenuItem(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 4
        && info[0]->IsString()
        && info[1]->IsString()
        && info[2]->IsString()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(info[3]))
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          Platform::String^ arg2 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[2])));
          ::Windows::Foundation::Uri^ arg3 = dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(info[3]));
          
          ::Windows::UI::Input::RadialControllerMenuItem^ result;
          result = ::Windows::UI::Input::RadialControllerMenuItem::CreateFromFontGlyph(arg0, arg1, arg2, arg3);
          info.GetReturnValue().Set(WrapRadialControllerMenuItem(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 CreateFromIcon(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && info[0]->IsString()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::RandomAccessStreamReference^>(info[1]))
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Storage::Streams::RandomAccessStreamReference^ arg1 = dynamic_cast<::Windows::Storage::Streams::RandomAccessStreamReference^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          ::Windows::UI::Input::RadialControllerMenuItem^ result;
          result = ::Windows::UI::Input::RadialControllerMenuItem::CreateFromIcon(arg0, arg1);
          info.GetReturnValue().Set(WrapRadialControllerMenuItem(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 CreateFromKnownIcon(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && info[0]->IsString()
        && info[1]->IsInt32())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::UI::Input::RadialControllerMenuKnownIcon arg1 = static_cast<::Windows::UI::Input::RadialControllerMenuKnownIcon>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          ::Windows::UI::Input::RadialControllerMenuItem^ result;
          result = ::Windows::UI::Input::RadialControllerMenuItem::CreateFromKnownIcon(arg0, arg1);
          info.GetReturnValue().Set(WrapRadialControllerMenuItem(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 TagGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

      RadialControllerMenuItem *wrapper = RadialControllerMenuItem::Unwrap<RadialControllerMenuItem>(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::Input::RadialControllerMenuItem^>(info.This())) {
        return;
      }

      RadialControllerMenuItem *wrapper = RadialControllerMenuItem::Unwrap<RadialControllerMenuItem>(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 DisplayTextGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

      try  {
        Platform::String^ result = wrapper->_instance->DisplayText;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        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"invoked", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialControllerMenuItem^>(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;
        }
        RadialControllerMenuItem *wrapper = RadialControllerMenuItem::Unwrap<RadialControllerMenuItem>(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->Invoked::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::RadialControllerMenuItem^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::UI::Input::RadialControllerMenuItem^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapRadialControllerMenuItem(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"invoked", 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"invoked", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialControllerMenuItem^>(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;
          }
          RadialControllerMenuItem *wrapper = RadialControllerMenuItem::Unwrap<RadialControllerMenuItem>(info.This());
          wrapper->_instance->Invoked::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::Input::RadialControllerMenuItem^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapRadialControllerMenuItem(::Windows::UI::Input::RadialControllerMenuItem^ wintRtInstance);
      friend ::Windows::UI::Input::RadialControllerMenuItem^ UnwrapRadialControllerMenuItem(Local<Value> value);
  };

  Persistent<FunctionTemplate> RadialControllerMenuItem::s_constructorTemplate;

  v8::Local<v8::Value> WrapRadialControllerMenuItem(::Windows::UI::Input::RadialControllerMenuItem^ 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>(RadialControllerMenuItem::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::RadialControllerMenuItem^ UnwrapRadialControllerMenuItem(Local<Value> value) {
     return RadialControllerMenuItem::Unwrap<RadialControllerMenuItem>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitRadialControllerMenuItem(Local<Object> exports) {
    RadialControllerMenuItem::Init(exports);
  }

  class RadialControllerRotationChangedEventArgs : 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>("RadialControllerRotationChangedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("contact").ToLocalChecked(), ContactGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("rotationDeltaInDegrees").ToLocalChecked(), RotationDeltaInDegreesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isButtonPressed").ToLocalChecked(), IsButtonPressedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("simpleHapticsController").ToLocalChecked(), SimpleHapticsControllerGetter);

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



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

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

    private:

      RadialControllerRotationChangedEventArgs(::Windows::UI::Input::RadialControllerRotationChangedEventArgs^ 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::Input::RadialControllerRotationChangedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialControllerRotationChangedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::RadialControllerRotationChangedEventArgs^) 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());

      RadialControllerRotationChangedEventArgs *wrapperInstance = new RadialControllerRotationChangedEventArgs(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::Input::RadialControllerRotationChangedEventArgs^>(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::Input::RadialControllerRotationChangedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::RadialControllerRotationChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

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

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

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

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

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

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

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

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

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

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


    private:
      ::Windows::UI::Input::RadialControllerRotationChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapRadialControllerRotationChangedEventArgs(::Windows::UI::Input::RadialControllerRotationChangedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::RadialControllerRotationChangedEventArgs^ UnwrapRadialControllerRotationChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> RadialControllerRotationChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapRadialControllerRotationChangedEventArgs(::Windows::UI::Input::RadialControllerRotationChangedEventArgs^ 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>(RadialControllerRotationChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::RadialControllerRotationChangedEventArgs^ UnwrapRadialControllerRotationChangedEventArgs(Local<Value> value) {
     return RadialControllerRotationChangedEventArgs::Unwrap<RadialControllerRotationChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitRadialControllerRotationChangedEventArgs(Local<Object> exports) {
    RadialControllerRotationChangedEventArgs::Init(exports);
  }

  class RadialControllerScreenContact : 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>("RadialControllerScreenContact").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("bounds").ToLocalChecked(), BoundsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("position").ToLocalChecked(), PositionGetter);

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



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

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

    private:

      RadialControllerScreenContact(::Windows::UI::Input::RadialControllerScreenContact^ 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::Input::RadialControllerScreenContact^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialControllerScreenContact^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::RadialControllerScreenContact^) 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());

      RadialControllerScreenContact *wrapperInstance = new RadialControllerScreenContact(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::Input::RadialControllerScreenContact^>(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::Input::RadialControllerScreenContact^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::RadialControllerScreenContact^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

      RadialControllerScreenContact *wrapper = RadialControllerScreenContact::Unwrap<RadialControllerScreenContact>(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 PositionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

      try  {
        ::Windows::Foundation::Point result = wrapper->_instance->Position;
        info.GetReturnValue().Set(NodeRT::Utils::PointToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::RadialControllerScreenContact^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapRadialControllerScreenContact(::Windows::UI::Input::RadialControllerScreenContact^ wintRtInstance);
      friend ::Windows::UI::Input::RadialControllerScreenContact^ UnwrapRadialControllerScreenContact(Local<Value> value);
  };

  Persistent<FunctionTemplate> RadialControllerScreenContact::s_constructorTemplate;

  v8::Local<v8::Value> WrapRadialControllerScreenContact(::Windows::UI::Input::RadialControllerScreenContact^ 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>(RadialControllerScreenContact::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::RadialControllerScreenContact^ UnwrapRadialControllerScreenContact(Local<Value> value) {
     return RadialControllerScreenContact::Unwrap<RadialControllerScreenContact>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitRadialControllerScreenContact(Local<Object> exports) {
    RadialControllerScreenContact::Init(exports);
  }

  class RadialControllerScreenContactContinuedEventArgs : 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>("RadialControllerScreenContactContinuedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("contact").ToLocalChecked(), ContactGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isButtonPressed").ToLocalChecked(), IsButtonPressedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("simpleHapticsController").ToLocalChecked(), SimpleHapticsControllerGetter);

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



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

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

    private:

      RadialControllerScreenContactContinuedEventArgs(::Windows::UI::Input::RadialControllerScreenContactContinuedEventArgs^ 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::Input::RadialControllerScreenContactContinuedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialControllerScreenContactContinuedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::RadialControllerScreenContactContinuedEventArgs^) 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());

      RadialControllerScreenContactContinuedEventArgs *wrapperInstance = new RadialControllerScreenContactContinuedEventArgs(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::Input::RadialControllerScreenContactContinuedEventArgs^>(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::Input::RadialControllerScreenContactContinuedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::RadialControllerScreenContactContinuedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

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

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

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

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

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

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

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


    private:
      ::Windows::UI::Input::RadialControllerScreenContactContinuedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapRadialControllerScreenContactContinuedEventArgs(::Windows::UI::Input::RadialControllerScreenContactContinuedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::RadialControllerScreenContactContinuedEventArgs^ UnwrapRadialControllerScreenContactContinuedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> RadialControllerScreenContactContinuedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapRadialControllerScreenContactContinuedEventArgs(::Windows::UI::Input::RadialControllerScreenContactContinuedEventArgs^ 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>(RadialControllerScreenContactContinuedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::RadialControllerScreenContactContinuedEventArgs^ UnwrapRadialControllerScreenContactContinuedEventArgs(Local<Value> value) {
     return RadialControllerScreenContactContinuedEventArgs::Unwrap<RadialControllerScreenContactContinuedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitRadialControllerScreenContactContinuedEventArgs(Local<Object> exports) {
    RadialControllerScreenContactContinuedEventArgs::Init(exports);
  }

  class RadialControllerScreenContactEndedEventArgs : 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>("RadialControllerScreenContactEndedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isButtonPressed").ToLocalChecked(), IsButtonPressedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("simpleHapticsController").ToLocalChecked(), SimpleHapticsControllerGetter);

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



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

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

    private:

      RadialControllerScreenContactEndedEventArgs(::Windows::UI::Input::RadialControllerScreenContactEndedEventArgs^ 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::Input::RadialControllerScreenContactEndedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialControllerScreenContactEndedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::RadialControllerScreenContactEndedEventArgs^) 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());

      RadialControllerScreenContactEndedEventArgs *wrapperInstance = new RadialControllerScreenContactEndedEventArgs(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::Input::RadialControllerScreenContactEndedEventArgs^>(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::Input::RadialControllerScreenContactEndedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::RadialControllerScreenContactEndedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

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

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

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

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


    private:
      ::Windows::UI::Input::RadialControllerScreenContactEndedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapRadialControllerScreenContactEndedEventArgs(::Windows::UI::Input::RadialControllerScreenContactEndedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::RadialControllerScreenContactEndedEventArgs^ UnwrapRadialControllerScreenContactEndedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> RadialControllerScreenContactEndedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapRadialControllerScreenContactEndedEventArgs(::Windows::UI::Input::RadialControllerScreenContactEndedEventArgs^ 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>(RadialControllerScreenContactEndedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::RadialControllerScreenContactEndedEventArgs^ UnwrapRadialControllerScreenContactEndedEventArgs(Local<Value> value) {
     return RadialControllerScreenContactEndedEventArgs::Unwrap<RadialControllerScreenContactEndedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitRadialControllerScreenContactEndedEventArgs(Local<Object> exports) {
    RadialControllerScreenContactEndedEventArgs::Init(exports);
  }

  class RadialControllerScreenContactStartedEventArgs : 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>("RadialControllerScreenContactStartedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("contact").ToLocalChecked(), ContactGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isButtonPressed").ToLocalChecked(), IsButtonPressedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("simpleHapticsController").ToLocalChecked(), SimpleHapticsControllerGetter);

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



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

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

    private:

      RadialControllerScreenContactStartedEventArgs(::Windows::UI::Input::RadialControllerScreenContactStartedEventArgs^ 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::Input::RadialControllerScreenContactStartedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RadialControllerScreenContactStartedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::RadialControllerScreenContactStartedEventArgs^) 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());

      RadialControllerScreenContactStartedEventArgs *wrapperInstance = new RadialControllerScreenContactStartedEventArgs(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::Input::RadialControllerScreenContactStartedEventArgs^>(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::Input::RadialControllerScreenContactStartedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::RadialControllerScreenContactStartedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

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

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

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

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

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

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

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


    private:
      ::Windows::UI::Input::RadialControllerScreenContactStartedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapRadialControllerScreenContactStartedEventArgs(::Windows::UI::Input::RadialControllerScreenContactStartedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::RadialControllerScreenContactStartedEventArgs^ UnwrapRadialControllerScreenContactStartedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> RadialControllerScreenContactStartedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapRadialControllerScreenContactStartedEventArgs(::Windows::UI::Input::RadialControllerScreenContactStartedEventArgs^ 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>(RadialControllerScreenContactStartedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::RadialControllerScreenContactStartedEventArgs^ UnwrapRadialControllerScreenContactStartedEventArgs(Local<Value> value) {
     return RadialControllerScreenContactStartedEventArgs::Unwrap<RadialControllerScreenContactStartedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitRadialControllerScreenContactStartedEventArgs(Local<Object> exports) {
    RadialControllerScreenContactStartedEventArgs::Init(exports);
  }

  class RightTappedEventArgs : 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>("RightTappedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pointerDeviceType").ToLocalChecked(), PointerDeviceTypeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("position").ToLocalChecked(), PositionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("contactCount").ToLocalChecked(), ContactCountGetter);

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



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

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

    private:

      RightTappedEventArgs(::Windows::UI::Input::RightTappedEventArgs^ 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::Input::RightTappedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::RightTappedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::RightTappedEventArgs^) 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());

      RightTappedEventArgs *wrapperInstance = new RightTappedEventArgs(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::Input::RightTappedEventArgs^>(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::Input::RightTappedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::RightTappedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

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

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

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

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

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

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

      try  {
        unsigned int result = wrapper->_instance->ContactCount;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::RightTappedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapRightTappedEventArgs(::Windows::UI::Input::RightTappedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::RightTappedEventArgs^ UnwrapRightTappedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> RightTappedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapRightTappedEventArgs(::Windows::UI::Input::RightTappedEventArgs^ 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>(RightTappedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::RightTappedEventArgs^ UnwrapRightTappedEventArgs(Local<Value> value) {
     return RightTappedEventArgs::Unwrap<RightTappedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitRightTappedEventArgs(Local<Object> exports) {
    RightTappedEventArgs::Init(exports);
  }

  class SystemButtonEventController : 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>("SystemButtonEventController").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);


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

        Nan::SetMethod(constructor, "createForDispatcherQueue", CreateForDispatcherQueue);


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

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

    private:

      SystemButtonEventController(::Windows::UI::Input::SystemButtonEventController^ 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::Input::SystemButtonEventController^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::SystemButtonEventController^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::SystemButtonEventController^) 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());

      SystemButtonEventController *wrapperInstance = new SystemButtonEventController(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::Input::SystemButtonEventController^>(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::Input::SystemButtonEventController^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::SystemButtonEventController^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::System::DispatcherQueue^>(info[0]))
      {
        try
        {
          ::Windows::System::DispatcherQueue^ arg0 = dynamic_cast<::Windows::System::DispatcherQueue^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::UI::Input::SystemButtonEventController^ result;
          result = ::Windows::UI::Input::SystemButtonEventController::CreateForDispatcherQueue(arg0);
          info.GetReturnValue().Set(WrapSystemButtonEventController(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 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"systemFunctionButtonPressed", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::SystemButtonEventController^>(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;
        }
        SystemButtonEventController *wrapper = SystemButtonEventController::Unwrap<SystemButtonEventController>(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->SystemFunctionButtonPressed::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::SystemButtonEventController^, ::Windows::UI::Input::SystemFunctionButtonEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::SystemButtonEventController^ arg0, ::Windows::UI::Input::SystemFunctionButtonEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapSystemButtonEventController(arg0);
                  wrappedArg1 = WrapSystemFunctionButtonEventArgs(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"systemFunctionButtonReleased", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::SystemButtonEventController^>(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;
        }
        SystemButtonEventController *wrapper = SystemButtonEventController::Unwrap<SystemButtonEventController>(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->SystemFunctionButtonReleased::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::SystemButtonEventController^, ::Windows::UI::Input::SystemFunctionButtonEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::SystemButtonEventController^ arg0, ::Windows::UI::Input::SystemFunctionButtonEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapSystemButtonEventController(arg0);
                  wrappedArg1 = WrapSystemFunctionButtonEventArgs(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"systemFunctionLockChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::SystemButtonEventController^>(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;
        }
        SystemButtonEventController *wrapper = SystemButtonEventController::Unwrap<SystemButtonEventController>(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->SystemFunctionLockChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::SystemButtonEventController^, ::Windows::UI::Input::SystemFunctionLockChangedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::SystemButtonEventController^ arg0, ::Windows::UI::Input::SystemFunctionLockChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapSystemButtonEventController(arg0);
                  wrappedArg1 = WrapSystemFunctionLockChangedEventArgs(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"systemFunctionLockIndicatorChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::SystemButtonEventController^>(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;
        }
        SystemButtonEventController *wrapper = SystemButtonEventController::Unwrap<SystemButtonEventController>(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->SystemFunctionLockIndicatorChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::SystemButtonEventController^, ::Windows::UI::Input::SystemFunctionLockIndicatorChangedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::SystemButtonEventController^ arg0, ::Windows::UI::Input::SystemFunctionLockIndicatorChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapSystemButtonEventController(arg0);
                  wrappedArg1 = WrapSystemFunctionLockIndicatorChangedEventArgs(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"systemFunctionButtonPressed", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"systemFunctionButtonReleased", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"systemFunctionLockChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"systemFunctionLockIndicatorChanged", 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"systemFunctionButtonPressed", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::SystemButtonEventController^>(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;
          }
          SystemButtonEventController *wrapper = SystemButtonEventController::Unwrap<SystemButtonEventController>(info.This());
          wrapper->_instance->SystemFunctionButtonPressed::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"systemFunctionButtonReleased", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::SystemButtonEventController^>(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;
          }
          SystemButtonEventController *wrapper = SystemButtonEventController::Unwrap<SystemButtonEventController>(info.This());
          wrapper->_instance->SystemFunctionButtonReleased::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"systemFunctionLockChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::SystemButtonEventController^>(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;
          }
          SystemButtonEventController *wrapper = SystemButtonEventController::Unwrap<SystemButtonEventController>(info.This());
          wrapper->_instance->SystemFunctionLockChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"systemFunctionLockIndicatorChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::SystemButtonEventController^>(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;
          }
          SystemButtonEventController *wrapper = SystemButtonEventController::Unwrap<SystemButtonEventController>(info.This());
          wrapper->_instance->SystemFunctionLockIndicatorChanged::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::Input::SystemButtonEventController^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapSystemButtonEventController(::Windows::UI::Input::SystemButtonEventController^ wintRtInstance);
      friend ::Windows::UI::Input::SystemButtonEventController^ UnwrapSystemButtonEventController(Local<Value> value);
  };

  Persistent<FunctionTemplate> SystemButtonEventController::s_constructorTemplate;

  v8::Local<v8::Value> WrapSystemButtonEventController(::Windows::UI::Input::SystemButtonEventController^ 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>(SystemButtonEventController::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::SystemButtonEventController^ UnwrapSystemButtonEventController(Local<Value> value) {
     return SystemButtonEventController::Unwrap<SystemButtonEventController>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitSystemButtonEventController(Local<Object> exports) {
    SystemButtonEventController::Init(exports);
  }

  class SystemFunctionButtonEventArgs : 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>("SystemFunctionButtonEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("handled").ToLocalChecked(), HandledGetter, HandledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("timestamp").ToLocalChecked(), TimestampGetter);

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



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

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

    private:

      SystemFunctionButtonEventArgs(::Windows::UI::Input::SystemFunctionButtonEventArgs^ 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::Input::SystemFunctionButtonEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::SystemFunctionButtonEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::SystemFunctionButtonEventArgs^) 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());

      SystemFunctionButtonEventArgs *wrapperInstance = new SystemFunctionButtonEventArgs(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::Input::SystemFunctionButtonEventArgs^>(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::Input::SystemFunctionButtonEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::SystemFunctionButtonEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

      SystemFunctionButtonEventArgs *wrapper = SystemFunctionButtonEventArgs::Unwrap<SystemFunctionButtonEventArgs>(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::Input::SystemFunctionButtonEventArgs^>(info.This())) {
        return;
      }

      SystemFunctionButtonEventArgs *wrapper = SystemFunctionButtonEventArgs::Unwrap<SystemFunctionButtonEventArgs>(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 TimestampGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

      try  {
        unsigned __int64 result = wrapper->_instance->Timestamp;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::SystemFunctionButtonEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapSystemFunctionButtonEventArgs(::Windows::UI::Input::SystemFunctionButtonEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::SystemFunctionButtonEventArgs^ UnwrapSystemFunctionButtonEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> SystemFunctionButtonEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapSystemFunctionButtonEventArgs(::Windows::UI::Input::SystemFunctionButtonEventArgs^ 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>(SystemFunctionButtonEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::SystemFunctionButtonEventArgs^ UnwrapSystemFunctionButtonEventArgs(Local<Value> value) {
     return SystemFunctionButtonEventArgs::Unwrap<SystemFunctionButtonEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitSystemFunctionButtonEventArgs(Local<Object> exports) {
    SystemFunctionButtonEventArgs::Init(exports);
  }

  class SystemFunctionLockChangedEventArgs : 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>("SystemFunctionLockChangedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("handled").ToLocalChecked(), HandledGetter, HandledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isLocked").ToLocalChecked(), IsLockedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("timestamp").ToLocalChecked(), TimestampGetter);

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



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

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

    private:

      SystemFunctionLockChangedEventArgs(::Windows::UI::Input::SystemFunctionLockChangedEventArgs^ 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::Input::SystemFunctionLockChangedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::SystemFunctionLockChangedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::SystemFunctionLockChangedEventArgs^) 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());

      SystemFunctionLockChangedEventArgs *wrapperInstance = new SystemFunctionLockChangedEventArgs(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::Input::SystemFunctionLockChangedEventArgs^>(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::Input::SystemFunctionLockChangedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::SystemFunctionLockChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

      SystemFunctionLockChangedEventArgs *wrapper = SystemFunctionLockChangedEventArgs::Unwrap<SystemFunctionLockChangedEventArgs>(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::Input::SystemFunctionLockChangedEventArgs^>(info.This())) {
        return;
      }

      SystemFunctionLockChangedEventArgs *wrapper = SystemFunctionLockChangedEventArgs::Unwrap<SystemFunctionLockChangedEventArgs>(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 IsLockedGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

      try  {
        unsigned __int64 result = wrapper->_instance->Timestamp;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::SystemFunctionLockChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapSystemFunctionLockChangedEventArgs(::Windows::UI::Input::SystemFunctionLockChangedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::SystemFunctionLockChangedEventArgs^ UnwrapSystemFunctionLockChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> SystemFunctionLockChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapSystemFunctionLockChangedEventArgs(::Windows::UI::Input::SystemFunctionLockChangedEventArgs^ 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>(SystemFunctionLockChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::SystemFunctionLockChangedEventArgs^ UnwrapSystemFunctionLockChangedEventArgs(Local<Value> value) {
     return SystemFunctionLockChangedEventArgs::Unwrap<SystemFunctionLockChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitSystemFunctionLockChangedEventArgs(Local<Object> exports) {
    SystemFunctionLockChangedEventArgs::Init(exports);
  }

  class SystemFunctionLockIndicatorChangedEventArgs : 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>("SystemFunctionLockIndicatorChangedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("handled").ToLocalChecked(), HandledGetter, HandledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isIndicatorOn").ToLocalChecked(), IsIndicatorOnGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("timestamp").ToLocalChecked(), TimestampGetter);

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



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

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

    private:

      SystemFunctionLockIndicatorChangedEventArgs(::Windows::UI::Input::SystemFunctionLockIndicatorChangedEventArgs^ 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::Input::SystemFunctionLockIndicatorChangedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::SystemFunctionLockIndicatorChangedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::SystemFunctionLockIndicatorChangedEventArgs^) 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());

      SystemFunctionLockIndicatorChangedEventArgs *wrapperInstance = new SystemFunctionLockIndicatorChangedEventArgs(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::Input::SystemFunctionLockIndicatorChangedEventArgs^>(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::Input::SystemFunctionLockIndicatorChangedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::SystemFunctionLockIndicatorChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

      SystemFunctionLockIndicatorChangedEventArgs *wrapper = SystemFunctionLockIndicatorChangedEventArgs::Unwrap<SystemFunctionLockIndicatorChangedEventArgs>(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::Input::SystemFunctionLockIndicatorChangedEventArgs^>(info.This())) {
        return;
      }

      SystemFunctionLockIndicatorChangedEventArgs *wrapper = SystemFunctionLockIndicatorChangedEventArgs::Unwrap<SystemFunctionLockIndicatorChangedEventArgs>(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 IsIndicatorOnGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

      try  {
        unsigned __int64 result = wrapper->_instance->Timestamp;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::SystemFunctionLockIndicatorChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapSystemFunctionLockIndicatorChangedEventArgs(::Windows::UI::Input::SystemFunctionLockIndicatorChangedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::SystemFunctionLockIndicatorChangedEventArgs^ UnwrapSystemFunctionLockIndicatorChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> SystemFunctionLockIndicatorChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapSystemFunctionLockIndicatorChangedEventArgs(::Windows::UI::Input::SystemFunctionLockIndicatorChangedEventArgs^ 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>(SystemFunctionLockIndicatorChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::SystemFunctionLockIndicatorChangedEventArgs^ UnwrapSystemFunctionLockIndicatorChangedEventArgs(Local<Value> value) {
     return SystemFunctionLockIndicatorChangedEventArgs::Unwrap<SystemFunctionLockIndicatorChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitSystemFunctionLockIndicatorChangedEventArgs(Local<Object> exports) {
    SystemFunctionLockIndicatorChangedEventArgs::Init(exports);
  }

  class TappedEventArgs : 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>("TappedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pointerDeviceType").ToLocalChecked(), PointerDeviceTypeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("position").ToLocalChecked(), PositionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("tapCount").ToLocalChecked(), TapCountGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("contactCount").ToLocalChecked(), ContactCountGetter);

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



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

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

    private:

      TappedEventArgs(::Windows::UI::Input::TappedEventArgs^ 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::Input::TappedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::TappedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::TappedEventArgs^) 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());

      TappedEventArgs *wrapperInstance = new TappedEventArgs(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::Input::TappedEventArgs^>(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::Input::TappedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::TappedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

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

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

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

      try  {
        ::Windows::Foundation::Point result = wrapper->_instance->Position;
        info.GetReturnValue().Set(NodeRT::Utils::PointToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TapCountGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::TappedEventArgs^>(info.This())) {
        return;
      }

      TappedEventArgs *wrapper = TappedEventArgs::Unwrap<TappedEventArgs>(info.This());

      try  {
        unsigned int result = wrapper->_instance->TapCount;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ContactCountGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::TappedEventArgs^>(info.This())) {
        return;
      }

      TappedEventArgs *wrapper = TappedEventArgs::Unwrap<TappedEventArgs>(info.This());

      try  {
        unsigned int result = wrapper->_instance->ContactCount;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::TappedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapTappedEventArgs(::Windows::UI::Input::TappedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::TappedEventArgs^ UnwrapTappedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> TappedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapTappedEventArgs(::Windows::UI::Input::TappedEventArgs^ 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>(TappedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::TappedEventArgs^ UnwrapTappedEventArgs(Local<Value> value) {
     return TappedEventArgs::Unwrap<TappedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitTappedEventArgs(Local<Object> exports) {
    TappedEventArgs::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::Input::InitCrossSlidingStateEnum(target);
      NodeRT::Windows::UI::Input::InitDraggingStateEnum(target);
      NodeRT::Windows::UI::Input::InitEdgeGestureKindEnum(target);
      NodeRT::Windows::UI::Input::InitGazeInputAccessStatusEnum(target);
      NodeRT::Windows::UI::Input::InitGestureSettingsEnum(target);
      NodeRT::Windows::UI::Input::InitHoldingStateEnum(target);
      NodeRT::Windows::UI::Input::InitInputActivationStateEnum(target);
      NodeRT::Windows::UI::Input::InitPointerUpdateKindEnum(target);
      NodeRT::Windows::UI::Input::InitRadialControllerMenuKnownIconEnum(target);
      NodeRT::Windows::UI::Input::InitRadialControllerSystemMenuItemKindEnum(target);
      NodeRT::Windows::UI::Input::InitAttachableInputObject(target);
      NodeRT::Windows::UI::Input::InitCrossSlidingEventArgs(target);
      NodeRT::Windows::UI::Input::InitDraggingEventArgs(target);
      NodeRT::Windows::UI::Input::InitEdgeGesture(target);
      NodeRT::Windows::UI::Input::InitEdgeGestureEventArgs(target);
      NodeRT::Windows::UI::Input::InitGestureRecognizer(target);
      NodeRT::Windows::UI::Input::InitHoldingEventArgs(target);
      NodeRT::Windows::UI::Input::InitIPointerPointTransform(target);
      NodeRT::Windows::UI::Input::InitInputActivationListener(target);
      NodeRT::Windows::UI::Input::InitInputActivationListenerActivationChangedEventArgs(target);
      NodeRT::Windows::UI::Input::InitKeyboardDeliveryInterceptor(target);
      NodeRT::Windows::UI::Input::InitManipulationCompletedEventArgs(target);
      NodeRT::Windows::UI::Input::InitManipulationInertiaStartingEventArgs(target);
      NodeRT::Windows::UI::Input::InitManipulationStartedEventArgs(target);
      NodeRT::Windows::UI::Input::InitManipulationUpdatedEventArgs(target);
      NodeRT::Windows::UI::Input::InitMouseWheelParameters(target);
      NodeRT::Windows::UI::Input::InitPointerPoint(target);
      NodeRT::Windows::UI::Input::InitPointerPointProperties(target);
      NodeRT::Windows::UI::Input::InitPointerVisualizationSettings(target);
      NodeRT::Windows::UI::Input::InitRadialController(target);
      NodeRT::Windows::UI::Input::InitRadialControllerButtonClickedEventArgs(target);
      NodeRT::Windows::UI::Input::InitRadialControllerButtonHoldingEventArgs(target);
      NodeRT::Windows::UI::Input::InitRadialControllerButtonPressedEventArgs(target);
      NodeRT::Windows::UI::Input::InitRadialControllerButtonReleasedEventArgs(target);
      NodeRT::Windows::UI::Input::InitRadialControllerConfiguration(target);
      NodeRT::Windows::UI::Input::InitRadialControllerControlAcquiredEventArgs(target);
      NodeRT::Windows::UI::Input::InitRadialControllerMenu(target);
      NodeRT::Windows::UI::Input::InitRadialControllerMenuItem(target);
      NodeRT::Windows::UI::Input::InitRadialControllerRotationChangedEventArgs(target);
      NodeRT::Windows::UI::Input::InitRadialControllerScreenContact(target);
      NodeRT::Windows::UI::Input::InitRadialControllerScreenContactContinuedEventArgs(target);
      NodeRT::Windows::UI::Input::InitRadialControllerScreenContactEndedEventArgs(target);
      NodeRT::Windows::UI::Input::InitRadialControllerScreenContactStartedEventArgs(target);
      NodeRT::Windows::UI::Input::InitRightTappedEventArgs(target);
      NodeRT::Windows::UI::Input::InitSystemButtonEventController(target);
      NodeRT::Windows::UI::Input::InitSystemFunctionButtonEventArgs(target);
      NodeRT::Windows::UI::Input::InitSystemFunctionLockChangedEventArgs(target);
      NodeRT::Windows::UI::Input::InitSystemFunctionLockIndicatorChangedEventArgs(target);
      NodeRT::Windows::UI::Input::InitTappedEventArgs(target);


  NodeRT::Utils::RegisterNameSpace("Windows.UI.Input", target);
}



NODE_MODULE(binding, init)