// 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 { namespace Spatial { 
  v8::Local<v8::Value> WrapSpatialGestureRecognizer(::Windows::UI::Input::Spatial::SpatialGestureRecognizer^ wintRtInstance);
  ::Windows::UI::Input::Spatial::SpatialGestureRecognizer^ UnwrapSpatialGestureRecognizer(Local<Value> value);
  
  v8::Local<v8::Value> WrapSpatialHoldCanceledEventArgs(::Windows::UI::Input::Spatial::SpatialHoldCanceledEventArgs^ wintRtInstance);
  ::Windows::UI::Input::Spatial::SpatialHoldCanceledEventArgs^ UnwrapSpatialHoldCanceledEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapSpatialHoldCompletedEventArgs(::Windows::UI::Input::Spatial::SpatialHoldCompletedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::Spatial::SpatialHoldCompletedEventArgs^ UnwrapSpatialHoldCompletedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapSpatialHoldStartedEventArgs(::Windows::UI::Input::Spatial::SpatialHoldStartedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::Spatial::SpatialHoldStartedEventArgs^ UnwrapSpatialHoldStartedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapSpatialInteraction(::Windows::UI::Input::Spatial::SpatialInteraction^ wintRtInstance);
  ::Windows::UI::Input::Spatial::SpatialInteraction^ UnwrapSpatialInteraction(Local<Value> value);
  
  v8::Local<v8::Value> WrapSpatialInteractionController(::Windows::UI::Input::Spatial::SpatialInteractionController^ wintRtInstance);
  ::Windows::UI::Input::Spatial::SpatialInteractionController^ UnwrapSpatialInteractionController(Local<Value> value);
  
  v8::Local<v8::Value> WrapSpatialInteractionControllerProperties(::Windows::UI::Input::Spatial::SpatialInteractionControllerProperties^ wintRtInstance);
  ::Windows::UI::Input::Spatial::SpatialInteractionControllerProperties^ UnwrapSpatialInteractionControllerProperties(Local<Value> value);
  
  v8::Local<v8::Value> WrapSpatialInteractionDetectedEventArgs(::Windows::UI::Input::Spatial::SpatialInteractionDetectedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::Spatial::SpatialInteractionDetectedEventArgs^ UnwrapSpatialInteractionDetectedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapSpatialInteractionManager(::Windows::UI::Input::Spatial::SpatialInteractionManager^ wintRtInstance);
  ::Windows::UI::Input::Spatial::SpatialInteractionManager^ UnwrapSpatialInteractionManager(Local<Value> value);
  
  v8::Local<v8::Value> WrapSpatialInteractionSource(::Windows::UI::Input::Spatial::SpatialInteractionSource^ wintRtInstance);
  ::Windows::UI::Input::Spatial::SpatialInteractionSource^ UnwrapSpatialInteractionSource(Local<Value> value);
  
  v8::Local<v8::Value> WrapSpatialInteractionSourceEventArgs(::Windows::UI::Input::Spatial::SpatialInteractionSourceEventArgs^ wintRtInstance);
  ::Windows::UI::Input::Spatial::SpatialInteractionSourceEventArgs^ UnwrapSpatialInteractionSourceEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapSpatialInteractionSourceLocation(::Windows::UI::Input::Spatial::SpatialInteractionSourceLocation^ wintRtInstance);
  ::Windows::UI::Input::Spatial::SpatialInteractionSourceLocation^ UnwrapSpatialInteractionSourceLocation(Local<Value> value);
  
  v8::Local<v8::Value> WrapSpatialInteractionSourceProperties(::Windows::UI::Input::Spatial::SpatialInteractionSourceProperties^ wintRtInstance);
  ::Windows::UI::Input::Spatial::SpatialInteractionSourceProperties^ UnwrapSpatialInteractionSourceProperties(Local<Value> value);
  
  v8::Local<v8::Value> WrapSpatialInteractionSourceState(::Windows::UI::Input::Spatial::SpatialInteractionSourceState^ wintRtInstance);
  ::Windows::UI::Input::Spatial::SpatialInteractionSourceState^ UnwrapSpatialInteractionSourceState(Local<Value> value);
  
  v8::Local<v8::Value> WrapSpatialManipulationCanceledEventArgs(::Windows::UI::Input::Spatial::SpatialManipulationCanceledEventArgs^ wintRtInstance);
  ::Windows::UI::Input::Spatial::SpatialManipulationCanceledEventArgs^ UnwrapSpatialManipulationCanceledEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapSpatialManipulationCompletedEventArgs(::Windows::UI::Input::Spatial::SpatialManipulationCompletedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::Spatial::SpatialManipulationCompletedEventArgs^ UnwrapSpatialManipulationCompletedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapSpatialManipulationDelta(::Windows::UI::Input::Spatial::SpatialManipulationDelta^ wintRtInstance);
  ::Windows::UI::Input::Spatial::SpatialManipulationDelta^ UnwrapSpatialManipulationDelta(Local<Value> value);
  
  v8::Local<v8::Value> WrapSpatialManipulationStartedEventArgs(::Windows::UI::Input::Spatial::SpatialManipulationStartedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::Spatial::SpatialManipulationStartedEventArgs^ UnwrapSpatialManipulationStartedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapSpatialManipulationUpdatedEventArgs(::Windows::UI::Input::Spatial::SpatialManipulationUpdatedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::Spatial::SpatialManipulationUpdatedEventArgs^ UnwrapSpatialManipulationUpdatedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapSpatialNavigationCanceledEventArgs(::Windows::UI::Input::Spatial::SpatialNavigationCanceledEventArgs^ wintRtInstance);
  ::Windows::UI::Input::Spatial::SpatialNavigationCanceledEventArgs^ UnwrapSpatialNavigationCanceledEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapSpatialNavigationCompletedEventArgs(::Windows::UI::Input::Spatial::SpatialNavigationCompletedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::Spatial::SpatialNavigationCompletedEventArgs^ UnwrapSpatialNavigationCompletedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapSpatialNavigationStartedEventArgs(::Windows::UI::Input::Spatial::SpatialNavigationStartedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::Spatial::SpatialNavigationStartedEventArgs^ UnwrapSpatialNavigationStartedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapSpatialNavigationUpdatedEventArgs(::Windows::UI::Input::Spatial::SpatialNavigationUpdatedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::Spatial::SpatialNavigationUpdatedEventArgs^ UnwrapSpatialNavigationUpdatedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapSpatialPointerInteractionSourcePose(::Windows::UI::Input::Spatial::SpatialPointerInteractionSourcePose^ wintRtInstance);
  ::Windows::UI::Input::Spatial::SpatialPointerInteractionSourcePose^ UnwrapSpatialPointerInteractionSourcePose(Local<Value> value);
  
  v8::Local<v8::Value> WrapSpatialPointerPose(::Windows::UI::Input::Spatial::SpatialPointerPose^ wintRtInstance);
  ::Windows::UI::Input::Spatial::SpatialPointerPose^ UnwrapSpatialPointerPose(Local<Value> value);
  
  v8::Local<v8::Value> WrapSpatialRecognitionEndedEventArgs(::Windows::UI::Input::Spatial::SpatialRecognitionEndedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::Spatial::SpatialRecognitionEndedEventArgs^ UnwrapSpatialRecognitionEndedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapSpatialRecognitionStartedEventArgs(::Windows::UI::Input::Spatial::SpatialRecognitionStartedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::Spatial::SpatialRecognitionStartedEventArgs^ UnwrapSpatialRecognitionStartedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapSpatialTappedEventArgs(::Windows::UI::Input::Spatial::SpatialTappedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::Spatial::SpatialTappedEventArgs^ UnwrapSpatialTappedEventArgs(Local<Value> value);
  



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

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

    Nan::Set(exports, Nan::New<String>("SpatialGestureSettings").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Spatial::SpatialGestureSettings::None)));
    Nan::Set(enumObject, Nan::New<String>("tap").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Spatial::SpatialGestureSettings::Tap)));
    Nan::Set(enumObject, Nan::New<String>("doubleTap").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Spatial::SpatialGestureSettings::DoubleTap)));
    Nan::Set(enumObject, Nan::New<String>("hold").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Spatial::SpatialGestureSettings::Hold)));
    Nan::Set(enumObject, Nan::New<String>("manipulationTranslate").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Spatial::SpatialGestureSettings::ManipulationTranslate)));
    Nan::Set(enumObject, Nan::New<String>("navigationX").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Spatial::SpatialGestureSettings::NavigationX)));
    Nan::Set(enumObject, Nan::New<String>("navigationY").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Spatial::SpatialGestureSettings::NavigationY)));
    Nan::Set(enumObject, Nan::New<String>("navigationZ").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Spatial::SpatialGestureSettings::NavigationZ)));
    Nan::Set(enumObject, Nan::New<String>("navigationRailsX").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Spatial::SpatialGestureSettings::NavigationRailsX)));
    Nan::Set(enumObject, Nan::New<String>("navigationRailsY").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Spatial::SpatialGestureSettings::NavigationRailsY)));
    Nan::Set(enumObject, Nan::New<String>("navigationRailsZ").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Spatial::SpatialGestureSettings::NavigationRailsZ)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("SpatialInteractionPressKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Spatial::SpatialInteractionPressKind::None)));
    Nan::Set(enumObject, Nan::New<String>("select").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Spatial::SpatialInteractionPressKind::Select)));
    Nan::Set(enumObject, Nan::New<String>("menu").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Spatial::SpatialInteractionPressKind::Menu)));
    Nan::Set(enumObject, Nan::New<String>("grasp").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Spatial::SpatialInteractionPressKind::Grasp)));
    Nan::Set(enumObject, Nan::New<String>("touchpad").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Spatial::SpatialInteractionPressKind::Touchpad)));
    Nan::Set(enumObject, Nan::New<String>("thumbstick").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Spatial::SpatialInteractionPressKind::Thumbstick)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("SpatialInteractionSourceHandedness").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("unspecified").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Spatial::SpatialInteractionSourceHandedness::Unspecified)));
    Nan::Set(enumObject, Nan::New<String>("left").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Spatial::SpatialInteractionSourceHandedness::Left)));
    Nan::Set(enumObject, Nan::New<String>("right").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Spatial::SpatialInteractionSourceHandedness::Right)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("SpatialInteractionSourceKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("other").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Spatial::SpatialInteractionSourceKind::Other)));
    Nan::Set(enumObject, Nan::New<String>("hand").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Spatial::SpatialInteractionSourceKind::Hand)));
    Nan::Set(enumObject, Nan::New<String>("voice").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Spatial::SpatialInteractionSourceKind::Voice)));
    Nan::Set(enumObject, Nan::New<String>("controller").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Spatial::SpatialInteractionSourceKind::Controller)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("SpatialInteractionSourcePositionAccuracy").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("high").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Spatial::SpatialInteractionSourcePositionAccuracy::High)));
    Nan::Set(enumObject, Nan::New<String>("approximate").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Spatial::SpatialInteractionSourcePositionAccuracy::Approximate)));
  }


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

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

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

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

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

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

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

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

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

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

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

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

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

  ::Platform::Numerics::Quaternion QuaternionFromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Platform::Numerics::Quaternion returnValue;

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

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

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

  Local<Value> QuaternionToJsObject(::Platform::Numerics::Quaternion value) {
    EscapableHandleScope scope;

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

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

    return scope.Escape(obj);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "captureInteraction", CaptureInteraction);
            Nan::SetPrototypeMethod(localRef, "cancelPendingGestures", CancelPendingGestures);
            Nan::SetPrototypeMethod(localRef, "trySetGestureSettings", TrySetGestureSettings);
          


          
          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>("gestureSettings").ToLocalChecked(), GestureSettingsGetter);

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



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

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

    private:

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


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::Spatial::SpatialGestureRecognizer^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try {
          ::Windows::UI::Input::Spatial::SpatialGestureSettings arg0 = static_cast<::Windows::UI::Input::Spatial::SpatialGestureSettings>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          winRtInstance = ref new ::Windows::UI::Input::Spatial::SpatialGestureRecognizer(arg0);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

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

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

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


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

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

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

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

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

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

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

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

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

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::UI::Input::Spatial::SpatialGestureSettings arg0 = static_cast<::Windows::UI::Input::Spatial::SpatialGestureSettings>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          bool result;
          result = wrapper->_instance->TrySetGestureSettings(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 GestureSettingsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

      try  {
        ::Windows::UI::Input::Spatial::SpatialGestureSettings 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 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"holdCanceled", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        SpatialGestureRecognizer *wrapper = SpatialGestureRecognizer::Unwrap<SpatialGestureRecognizer>(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->HoldCanceled::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^, ::Windows::UI::Input::Spatial::SpatialHoldCanceledEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Spatial::SpatialGestureRecognizer^ arg0, ::Windows::UI::Input::Spatial::SpatialHoldCanceledEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapSpatialGestureRecognizer(arg0);
                  wrappedArg1 = WrapSpatialHoldCanceledEventArgs(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"holdCompleted", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        SpatialGestureRecognizer *wrapper = SpatialGestureRecognizer::Unwrap<SpatialGestureRecognizer>(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->HoldCompleted::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^, ::Windows::UI::Input::Spatial::SpatialHoldCompletedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Spatial::SpatialGestureRecognizer^ arg0, ::Windows::UI::Input::Spatial::SpatialHoldCompletedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapSpatialGestureRecognizer(arg0);
                  wrappedArg1 = WrapSpatialHoldCompletedEventArgs(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"holdStarted", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        SpatialGestureRecognizer *wrapper = SpatialGestureRecognizer::Unwrap<SpatialGestureRecognizer>(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->HoldStarted::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^, ::Windows::UI::Input::Spatial::SpatialHoldStartedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Spatial::SpatialGestureRecognizer^ arg0, ::Windows::UI::Input::Spatial::SpatialHoldStartedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapSpatialGestureRecognizer(arg0);
                  wrappedArg1 = WrapSpatialHoldStartedEventArgs(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"manipulationCanceled", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        SpatialGestureRecognizer *wrapper = SpatialGestureRecognizer::Unwrap<SpatialGestureRecognizer>(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->ManipulationCanceled::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^, ::Windows::UI::Input::Spatial::SpatialManipulationCanceledEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Spatial::SpatialGestureRecognizer^ arg0, ::Windows::UI::Input::Spatial::SpatialManipulationCanceledEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapSpatialGestureRecognizer(arg0);
                  wrappedArg1 = WrapSpatialManipulationCanceledEventArgs(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::Spatial::SpatialGestureRecognizer^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        SpatialGestureRecognizer *wrapper = SpatialGestureRecognizer::Unwrap<SpatialGestureRecognizer>(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::Spatial::SpatialGestureRecognizer^, ::Windows::UI::Input::Spatial::SpatialManipulationCompletedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Spatial::SpatialGestureRecognizer^ arg0, ::Windows::UI::Input::Spatial::SpatialManipulationCompletedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapSpatialGestureRecognizer(arg0);
                  wrappedArg1 = WrapSpatialManipulationCompletedEventArgs(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::Spatial::SpatialGestureRecognizer^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        SpatialGestureRecognizer *wrapper = SpatialGestureRecognizer::Unwrap<SpatialGestureRecognizer>(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::Spatial::SpatialGestureRecognizer^, ::Windows::UI::Input::Spatial::SpatialManipulationStartedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Spatial::SpatialGestureRecognizer^ arg0, ::Windows::UI::Input::Spatial::SpatialManipulationStartedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapSpatialGestureRecognizer(arg0);
                  wrappedArg1 = WrapSpatialManipulationStartedEventArgs(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::Spatial::SpatialGestureRecognizer^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        SpatialGestureRecognizer *wrapper = SpatialGestureRecognizer::Unwrap<SpatialGestureRecognizer>(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::Spatial::SpatialGestureRecognizer^, ::Windows::UI::Input::Spatial::SpatialManipulationUpdatedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Spatial::SpatialGestureRecognizer^ arg0, ::Windows::UI::Input::Spatial::SpatialManipulationUpdatedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapSpatialGestureRecognizer(arg0);
                  wrappedArg1 = WrapSpatialManipulationUpdatedEventArgs(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"navigationCanceled", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        SpatialGestureRecognizer *wrapper = SpatialGestureRecognizer::Unwrap<SpatialGestureRecognizer>(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->NavigationCanceled::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^, ::Windows::UI::Input::Spatial::SpatialNavigationCanceledEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Spatial::SpatialGestureRecognizer^ arg0, ::Windows::UI::Input::Spatial::SpatialNavigationCanceledEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapSpatialGestureRecognizer(arg0);
                  wrappedArg1 = WrapSpatialNavigationCanceledEventArgs(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"navigationCompleted", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        SpatialGestureRecognizer *wrapper = SpatialGestureRecognizer::Unwrap<SpatialGestureRecognizer>(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->NavigationCompleted::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^, ::Windows::UI::Input::Spatial::SpatialNavigationCompletedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Spatial::SpatialGestureRecognizer^ arg0, ::Windows::UI::Input::Spatial::SpatialNavigationCompletedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapSpatialGestureRecognizer(arg0);
                  wrappedArg1 = WrapSpatialNavigationCompletedEventArgs(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"navigationStarted", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        SpatialGestureRecognizer *wrapper = SpatialGestureRecognizer::Unwrap<SpatialGestureRecognizer>(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->NavigationStarted::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^, ::Windows::UI::Input::Spatial::SpatialNavigationStartedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Spatial::SpatialGestureRecognizer^ arg0, ::Windows::UI::Input::Spatial::SpatialNavigationStartedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapSpatialGestureRecognizer(arg0);
                  wrappedArg1 = WrapSpatialNavigationStartedEventArgs(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"navigationUpdated", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        SpatialGestureRecognizer *wrapper = SpatialGestureRecognizer::Unwrap<SpatialGestureRecognizer>(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->NavigationUpdated::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^, ::Windows::UI::Input::Spatial::SpatialNavigationUpdatedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Spatial::SpatialGestureRecognizer^ arg0, ::Windows::UI::Input::Spatial::SpatialNavigationUpdatedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapSpatialGestureRecognizer(arg0);
                  wrappedArg1 = WrapSpatialNavigationUpdatedEventArgs(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"recognitionEnded", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        SpatialGestureRecognizer *wrapper = SpatialGestureRecognizer::Unwrap<SpatialGestureRecognizer>(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->RecognitionEnded::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^, ::Windows::UI::Input::Spatial::SpatialRecognitionEndedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Spatial::SpatialGestureRecognizer^ arg0, ::Windows::UI::Input::Spatial::SpatialRecognitionEndedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapSpatialGestureRecognizer(arg0);
                  wrappedArg1 = WrapSpatialRecognitionEndedEventArgs(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"recognitionStarted", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        SpatialGestureRecognizer *wrapper = SpatialGestureRecognizer::Unwrap<SpatialGestureRecognizer>(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->RecognitionStarted::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^, ::Windows::UI::Input::Spatial::SpatialRecognitionStartedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Spatial::SpatialGestureRecognizer^ arg0, ::Windows::UI::Input::Spatial::SpatialRecognitionStartedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapSpatialGestureRecognizer(arg0);
                  wrappedArg1 = WrapSpatialRecognitionStartedEventArgs(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::Spatial::SpatialGestureRecognizer^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        SpatialGestureRecognizer *wrapper = SpatialGestureRecognizer::Unwrap<SpatialGestureRecognizer>(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::Spatial::SpatialGestureRecognizer^, ::Windows::UI::Input::Spatial::SpatialTappedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Spatial::SpatialGestureRecognizer^ arg0, ::Windows::UI::Input::Spatial::SpatialTappedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapSpatialGestureRecognizer(arg0);
                  wrappedArg1 = WrapSpatialTappedEventArgs(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"holdCanceled", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"holdCompleted", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"holdStarted", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"manipulationCanceled", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"manipulationCompleted", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"manipulationStarted", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"manipulationUpdated", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"navigationCanceled", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"navigationCompleted", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"navigationStarted", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"navigationUpdated", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"recognitionEnded", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"recognitionStarted", 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"holdCanceled", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          SpatialGestureRecognizer *wrapper = SpatialGestureRecognizer::Unwrap<SpatialGestureRecognizer>(info.This());
          wrapper->_instance->HoldCanceled::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"holdCompleted", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          SpatialGestureRecognizer *wrapper = SpatialGestureRecognizer::Unwrap<SpatialGestureRecognizer>(info.This());
          wrapper->_instance->HoldCompleted::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"holdStarted", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          SpatialGestureRecognizer *wrapper = SpatialGestureRecognizer::Unwrap<SpatialGestureRecognizer>(info.This());
          wrapper->_instance->HoldStarted::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"manipulationCanceled", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          SpatialGestureRecognizer *wrapper = SpatialGestureRecognizer::Unwrap<SpatialGestureRecognizer>(info.This());
          wrapper->_instance->ManipulationCanceled::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"manipulationCompleted", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          SpatialGestureRecognizer *wrapper = SpatialGestureRecognizer::Unwrap<SpatialGestureRecognizer>(info.This());
          wrapper->_instance->ManipulationCompleted::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"manipulationStarted", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          SpatialGestureRecognizer *wrapper = SpatialGestureRecognizer::Unwrap<SpatialGestureRecognizer>(info.This());
          wrapper->_instance->ManipulationStarted::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"manipulationUpdated", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          SpatialGestureRecognizer *wrapper = SpatialGestureRecognizer::Unwrap<SpatialGestureRecognizer>(info.This());
          wrapper->_instance->ManipulationUpdated::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"navigationCanceled", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          SpatialGestureRecognizer *wrapper = SpatialGestureRecognizer::Unwrap<SpatialGestureRecognizer>(info.This());
          wrapper->_instance->NavigationCanceled::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"navigationCompleted", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          SpatialGestureRecognizer *wrapper = SpatialGestureRecognizer::Unwrap<SpatialGestureRecognizer>(info.This());
          wrapper->_instance->NavigationCompleted::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"navigationStarted", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          SpatialGestureRecognizer *wrapper = SpatialGestureRecognizer::Unwrap<SpatialGestureRecognizer>(info.This());
          wrapper->_instance->NavigationStarted::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"navigationUpdated", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          SpatialGestureRecognizer *wrapper = SpatialGestureRecognizer::Unwrap<SpatialGestureRecognizer>(info.This());
          wrapper->_instance->NavigationUpdated::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"recognitionEnded", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          SpatialGestureRecognizer *wrapper = SpatialGestureRecognizer::Unwrap<SpatialGestureRecognizer>(info.This());
          wrapper->_instance->RecognitionEnded::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"recognitionStarted", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          SpatialGestureRecognizer *wrapper = SpatialGestureRecognizer::Unwrap<SpatialGestureRecognizer>(info.This());
          wrapper->_instance->RecognitionStarted::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"tapped", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialGestureRecognizer^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          SpatialGestureRecognizer *wrapper = SpatialGestureRecognizer::Unwrap<SpatialGestureRecognizer>(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::Spatial::SpatialGestureRecognizer^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapSpatialGestureRecognizer(::Windows::UI::Input::Spatial::SpatialGestureRecognizer^ wintRtInstance);
      friend ::Windows::UI::Input::Spatial::SpatialGestureRecognizer^ UnwrapSpatialGestureRecognizer(Local<Value> value);
  };

  Persistent<FunctionTemplate> SpatialGestureRecognizer::s_constructorTemplate;

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

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

  void InitSpatialGestureRecognizer(Local<Object> exports) {
    SpatialGestureRecognizer::Init(exports);
  }

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





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

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



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

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

    private:

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


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

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

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





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

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

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

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


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

      friend v8::Local<v8::Value> WrapSpatialHoldCanceledEventArgs(::Windows::UI::Input::Spatial::SpatialHoldCanceledEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::Spatial::SpatialHoldCanceledEventArgs^ UnwrapSpatialHoldCanceledEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> SpatialHoldCanceledEventArgs::s_constructorTemplate;

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

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

  void InitSpatialHoldCanceledEventArgs(Local<Object> exports) {
    SpatialHoldCanceledEventArgs::Init(exports);
  }

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





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

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



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

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

    private:

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


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

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

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





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

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

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

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


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

      friend v8::Local<v8::Value> WrapSpatialHoldCompletedEventArgs(::Windows::UI::Input::Spatial::SpatialHoldCompletedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::Spatial::SpatialHoldCompletedEventArgs^ UnwrapSpatialHoldCompletedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> SpatialHoldCompletedEventArgs::s_constructorTemplate;

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

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

  void InitSpatialHoldCompletedEventArgs(Local<Object> exports) {
    SpatialHoldCompletedEventArgs::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "tryGetPointerPose", TryGetPointerPose);
          



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

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



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

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

    private:

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


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

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

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


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

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Perception::Spatial::SpatialCoordinateSystem^>(info[0]))
      {
        try
        {
          ::Windows::Perception::Spatial::SpatialCoordinateSystem^ arg0 = dynamic_cast<::Windows::Perception::Spatial::SpatialCoordinateSystem^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::UI::Input::Spatial::SpatialPointerPose^ result;
          result = wrapper->_instance->TryGetPointerPose(arg0);
          info.GetReturnValue().Set(WrapSpatialPointerPose(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 InteractionSourceKindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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


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

      friend v8::Local<v8::Value> WrapSpatialHoldStartedEventArgs(::Windows::UI::Input::Spatial::SpatialHoldStartedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::Spatial::SpatialHoldStartedEventArgs^ UnwrapSpatialHoldStartedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> SpatialHoldStartedEventArgs::s_constructorTemplate;

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

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

  void InitSpatialHoldStartedEventArgs(Local<Object> exports) {
    SpatialHoldStartedEventArgs::Init(exports);
  }

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





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

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



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

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

    private:

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


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

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

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





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

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

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

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


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

      friend v8::Local<v8::Value> WrapSpatialInteraction(::Windows::UI::Input::Spatial::SpatialInteraction^ wintRtInstance);
      friend ::Windows::UI::Input::Spatial::SpatialInteraction^ UnwrapSpatialInteraction(Local<Value> value);
  };

  Persistent<FunctionTemplate> SpatialInteraction::s_constructorTemplate;

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

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

  void InitSpatialInteraction(Local<Object> exports) {
    SpatialInteraction::Init(exports);
  }

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

        Local<Function> func;
        Local<FunctionTemplate> funcTemplate;

          
            Nan::SetPrototypeMethod(localRef, "tryGetBatteryReport", TryGetBatteryReport);
          

          
            Nan::SetPrototypeMethod(localRef, "tryGetRenderableModelAsync", TryGetRenderableModelAsync);
          


          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("hasThumbstick").ToLocalChecked(), HasThumbstickGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("hasTouchpad").ToLocalChecked(), HasTouchpadGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("productId").ToLocalChecked(), ProductIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("simpleHapticsController").ToLocalChecked(), SimpleHapticsControllerGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("vendorId").ToLocalChecked(), VendorIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("version").ToLocalChecked(), VersionGetter);

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



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

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

    private:

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


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

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

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

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

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

      if (info.Length() == 0 || !info[info.Length() -1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: No callback was given")));
        return;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Storage::Streams::IRandomAccessStreamWithContentType^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->TryGetRenderableModelAsync();
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

      auto opTask = create_task(op);
      uv_async_t* asyncToken = NodeUtils::Async::GetAsyncToken(info[info.Length() -1].As<Function>());

      opTask.then( [asyncToken] (task<::Windows::Storage::Streams::IRandomAccessStreamWithContentType^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.Storage.Streams", "IRandomAccessStreamWithContentType", result);
              if (tryCatch.HasCaught())
              {
                error = Nan::To<Object>(tryCatch.Exception()).ToLocalChecked();
              }
              else
              {
                error = Undefined();
              }
              if (arg1.IsEmpty()) arg1 = Undefined();
            }
            Local<Value> args[] = {error, arg1};


            invokeCallback(_countof(args), args);
          });
        } catch (Platform::Exception^ exception) {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {
            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

            Local<Value> args[] = {error};
            invokeCallback(_countof(args), args);
          });
        }
      });
    }

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

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Devices::Power::BatteryReport^ result;
          result = wrapper->_instance->TryGetBatteryReport();
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Devices.Power", "BatteryReport", 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 HasThumbstickGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

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

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

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

      try  {
        unsigned short result = wrapper->_instance->ProductId;
        info.GetReturnValue().Set(Nan::New<Integer>(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::Spatial::SpatialInteractionController^>(info.This())) {
        return;
      }

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

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

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

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

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

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

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


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

      friend v8::Local<v8::Value> WrapSpatialInteractionController(::Windows::UI::Input::Spatial::SpatialInteractionController^ wintRtInstance);
      friend ::Windows::UI::Input::Spatial::SpatialInteractionController^ UnwrapSpatialInteractionController(Local<Value> value);
  };

  Persistent<FunctionTemplate> SpatialInteractionController::s_constructorTemplate;

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

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

  void InitSpatialInteractionController(Local<Object> exports) {
    SpatialInteractionController::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isThumbstickPressed").ToLocalChecked(), IsThumbstickPressedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isTouchpadPressed").ToLocalChecked(), IsTouchpadPressedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isTouchpadTouched").ToLocalChecked(), IsTouchpadTouchedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("thumbstickX").ToLocalChecked(), ThumbstickXGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("thumbstickY").ToLocalChecked(), ThumbstickYGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("touchpadX").ToLocalChecked(), TouchpadXGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("touchpadY").ToLocalChecked(), TouchpadYGetter);

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



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

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

    private:

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


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

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

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





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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

      friend v8::Local<v8::Value> WrapSpatialInteractionControllerProperties(::Windows::UI::Input::Spatial::SpatialInteractionControllerProperties^ wintRtInstance);
      friend ::Windows::UI::Input::Spatial::SpatialInteractionControllerProperties^ UnwrapSpatialInteractionControllerProperties(Local<Value> value);
  };

  Persistent<FunctionTemplate> SpatialInteractionControllerProperties::s_constructorTemplate;

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

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

  void InitSpatialInteractionControllerProperties(Local<Object> exports) {
    SpatialInteractionControllerProperties::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "tryGetPointerPose", TryGetPointerPose);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("interaction").ToLocalChecked(), InteractionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("interactionSourceKind").ToLocalChecked(), InteractionSourceKindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("interactionSource").ToLocalChecked(), InteractionSourceGetter);

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



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

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

    private:

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


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

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

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


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

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Perception::Spatial::SpatialCoordinateSystem^>(info[0]))
      {
        try
        {
          ::Windows::Perception::Spatial::SpatialCoordinateSystem^ arg0 = dynamic_cast<::Windows::Perception::Spatial::SpatialCoordinateSystem^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::UI::Input::Spatial::SpatialPointerPose^ result;
          result = wrapper->_instance->TryGetPointerPose(arg0);
          info.GetReturnValue().Set(WrapSpatialPointerPose(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 InteractionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

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

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

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

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


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

      friend v8::Local<v8::Value> WrapSpatialInteractionDetectedEventArgs(::Windows::UI::Input::Spatial::SpatialInteractionDetectedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::Spatial::SpatialInteractionDetectedEventArgs^ UnwrapSpatialInteractionDetectedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> SpatialInteractionDetectedEventArgs::s_constructorTemplate;

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

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

  void InitSpatialInteractionDetectedEventArgs(Local<Object> exports) {
    SpatialInteractionDetectedEventArgs::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getDetectedSourcesAtTimestamp", GetDetectedSourcesAtTimestamp);
          


          
          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, "isSourceKindSupported", IsSourceKindSupported);
        Nan::SetMethod(constructor, "getForCurrentView", GetForCurrentView);


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

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

    private:

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


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

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

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


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

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Perception::PerceptionTimestamp^>(info[0]))
      {
        try
        {
          ::Windows::Perception::PerceptionTimestamp^ arg0 = dynamic_cast<::Windows::Perception::PerceptionTimestamp^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Spatial::SpatialInteractionSourceState^>^ result;
          result = wrapper->_instance->GetDetectedSourcesAtTimestamp(arg0);
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Spatial::SpatialInteractionSourceState^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Spatial::SpatialInteractionSourceState^ val) -> Local<Value> {
              return WrapSpatialInteractionSourceState(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialInteractionSourceState^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Spatial::SpatialInteractionSourceState^ {
              return UnwrapSpatialInteractionSourceState(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 IsSourceKindSupported(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::UI::Input::Spatial::SpatialInteractionSourceKind arg0 = static_cast<::Windows::UI::Input::Spatial::SpatialInteractionSourceKind>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          bool result;
          result = ::Windows::UI::Input::Spatial::SpatialInteractionManager::IsSourceKindSupported(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::Spatial::SpatialInteractionManager^ result;
          result = ::Windows::UI::Input::Spatial::SpatialInteractionManager::GetForCurrentView();
          info.GetReturnValue().Set(WrapSpatialInteractionManager(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"interactionDetected", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialInteractionManager^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        SpatialInteractionManager *wrapper = SpatialInteractionManager::Unwrap<SpatialInteractionManager>(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->InteractionDetected::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Spatial::SpatialInteractionManager^, ::Windows::UI::Input::Spatial::SpatialInteractionDetectedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Spatial::SpatialInteractionManager^ arg0, ::Windows::UI::Input::Spatial::SpatialInteractionDetectedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapSpatialInteractionManager(arg0);
                  wrappedArg1 = WrapSpatialInteractionDetectedEventArgs(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"sourceDetected", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialInteractionManager^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        SpatialInteractionManager *wrapper = SpatialInteractionManager::Unwrap<SpatialInteractionManager>(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->SourceDetected::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Spatial::SpatialInteractionManager^, ::Windows::UI::Input::Spatial::SpatialInteractionSourceEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Spatial::SpatialInteractionManager^ arg0, ::Windows::UI::Input::Spatial::SpatialInteractionSourceEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapSpatialInteractionManager(arg0);
                  wrappedArg1 = WrapSpatialInteractionSourceEventArgs(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"sourceLost", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialInteractionManager^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        SpatialInteractionManager *wrapper = SpatialInteractionManager::Unwrap<SpatialInteractionManager>(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->SourceLost::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Spatial::SpatialInteractionManager^, ::Windows::UI::Input::Spatial::SpatialInteractionSourceEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Spatial::SpatialInteractionManager^ arg0, ::Windows::UI::Input::Spatial::SpatialInteractionSourceEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapSpatialInteractionManager(arg0);
                  wrappedArg1 = WrapSpatialInteractionSourceEventArgs(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"sourcePressed", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialInteractionManager^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        SpatialInteractionManager *wrapper = SpatialInteractionManager::Unwrap<SpatialInteractionManager>(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->SourcePressed::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Spatial::SpatialInteractionManager^, ::Windows::UI::Input::Spatial::SpatialInteractionSourceEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Spatial::SpatialInteractionManager^ arg0, ::Windows::UI::Input::Spatial::SpatialInteractionSourceEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapSpatialInteractionManager(arg0);
                  wrappedArg1 = WrapSpatialInteractionSourceEventArgs(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"sourceReleased", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialInteractionManager^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        SpatialInteractionManager *wrapper = SpatialInteractionManager::Unwrap<SpatialInteractionManager>(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->SourceReleased::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Spatial::SpatialInteractionManager^, ::Windows::UI::Input::Spatial::SpatialInteractionSourceEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Spatial::SpatialInteractionManager^ arg0, ::Windows::UI::Input::Spatial::SpatialInteractionSourceEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapSpatialInteractionManager(arg0);
                  wrappedArg1 = WrapSpatialInteractionSourceEventArgs(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"sourceUpdated", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialInteractionManager^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        SpatialInteractionManager *wrapper = SpatialInteractionManager::Unwrap<SpatialInteractionManager>(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->SourceUpdated::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Spatial::SpatialInteractionManager^, ::Windows::UI::Input::Spatial::SpatialInteractionSourceEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Spatial::SpatialInteractionManager^ arg0, ::Windows::UI::Input::Spatial::SpatialInteractionSourceEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapSpatialInteractionManager(arg0);
                  wrappedArg1 = WrapSpatialInteractionSourceEventArgs(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"interactionDetected", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"sourceDetected", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"sourceLost", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"sourcePressed", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"sourceReleased", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"sourceUpdated", 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"interactionDetected", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialInteractionManager^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          SpatialInteractionManager *wrapper = SpatialInteractionManager::Unwrap<SpatialInteractionManager>(info.This());
          wrapper->_instance->InteractionDetected::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"sourceDetected", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialInteractionManager^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          SpatialInteractionManager *wrapper = SpatialInteractionManager::Unwrap<SpatialInteractionManager>(info.This());
          wrapper->_instance->SourceDetected::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"sourceLost", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialInteractionManager^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          SpatialInteractionManager *wrapper = SpatialInteractionManager::Unwrap<SpatialInteractionManager>(info.This());
          wrapper->_instance->SourceLost::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"sourcePressed", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialInteractionManager^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          SpatialInteractionManager *wrapper = SpatialInteractionManager::Unwrap<SpatialInteractionManager>(info.This());
          wrapper->_instance->SourcePressed::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"sourceReleased", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialInteractionManager^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          SpatialInteractionManager *wrapper = SpatialInteractionManager::Unwrap<SpatialInteractionManager>(info.This());
          wrapper->_instance->SourceReleased::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"sourceUpdated", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialInteractionManager^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          SpatialInteractionManager *wrapper = SpatialInteractionManager::Unwrap<SpatialInteractionManager>(info.This());
          wrapper->_instance->SourceUpdated::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::Spatial::SpatialInteractionManager^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapSpatialInteractionManager(::Windows::UI::Input::Spatial::SpatialInteractionManager^ wintRtInstance);
      friend ::Windows::UI::Input::Spatial::SpatialInteractionManager^ UnwrapSpatialInteractionManager(Local<Value> value);
  };

  Persistent<FunctionTemplate> SpatialInteractionManager::s_constructorTemplate;

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

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

  void InitSpatialInteractionManager(Local<Object> exports) {
    SpatialInteractionManager::Init(exports);
  }

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

        Local<Function> func;
        Local<FunctionTemplate> funcTemplate;

          
            Nan::SetPrototypeMethod(localRef, "tryGetStateAtTimestamp", TryGetStateAtTimestamp);
            Nan::SetPrototypeMethod(localRef, "tryCreateHandMeshObserver", TryCreateHandMeshObserver);
          

          
            Nan::SetPrototypeMethod(localRef, "tryCreateHandMeshObserverAsync", TryCreateHandMeshObserverAsync);
          


          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("id").ToLocalChecked(), IdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("controller").ToLocalChecked(), ControllerGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isGraspSupported").ToLocalChecked(), IsGraspSupportedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isMenuSupported").ToLocalChecked(), IsMenuSupportedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isPointingSupported").ToLocalChecked(), IsPointingSupportedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("handedness").ToLocalChecked(), HandednessGetter);

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



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

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

    private:

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


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

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

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

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

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

      if (info.Length() == 0 || !info[info.Length() -1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: No callback was given")));
        return;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Perception::People::HandMeshObserver^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->TryCreateHandMeshObserverAsync();
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

      auto opTask = create_task(op);
      uv_async_t* asyncToken = NodeUtils::Async::GetAsyncToken(info[info.Length() -1].As<Function>());

      opTask.then( [asyncToken] (task<::Windows::Perception::People::HandMeshObserver^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.Perception.People", "HandMeshObserver", result);
              if (tryCatch.HasCaught())
              {
                error = Nan::To<Object>(tryCatch.Exception()).ToLocalChecked();
              }
              else
              {
                error = Undefined();
              }
              if (arg1.IsEmpty()) arg1 = Undefined();
            }
            Local<Value> args[] = {error, arg1};


            invokeCallback(_countof(args), args);
          });
        } catch (Platform::Exception^ exception) {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {
            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

            Local<Value> args[] = {error};
            invokeCallback(_countof(args), args);
          });
        }
      });
    }

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

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Perception::PerceptionTimestamp^>(info[0]))
      {
        try
        {
          ::Windows::Perception::PerceptionTimestamp^ arg0 = dynamic_cast<::Windows::Perception::PerceptionTimestamp^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::UI::Input::Spatial::SpatialInteractionSourceState^ result;
          result = wrapper->_instance->TryGetStateAtTimestamp(arg0);
          info.GetReturnValue().Set(WrapSpatialInteractionSourceState(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 TryCreateHandMeshObserver(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Perception::People::HandMeshObserver^ result;
          result = wrapper->_instance->TryCreateHandMeshObserver();
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Perception.People", "HandMeshObserver", 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 IdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

      friend v8::Local<v8::Value> WrapSpatialInteractionSource(::Windows::UI::Input::Spatial::SpatialInteractionSource^ wintRtInstance);
      friend ::Windows::UI::Input::Spatial::SpatialInteractionSource^ UnwrapSpatialInteractionSource(Local<Value> value);
  };

  Persistent<FunctionTemplate> SpatialInteractionSource::s_constructorTemplate;

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

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

  void InitSpatialInteractionSource(Local<Object> exports) {
    SpatialInteractionSource::Init(exports);
  }

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





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

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



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

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

    private:

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


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

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

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





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

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

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

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

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

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

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


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

      friend v8::Local<v8::Value> WrapSpatialInteractionSourceEventArgs(::Windows::UI::Input::Spatial::SpatialInteractionSourceEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::Spatial::SpatialInteractionSourceEventArgs^ UnwrapSpatialInteractionSourceEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> SpatialInteractionSourceEventArgs::s_constructorTemplate;

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

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

  void InitSpatialInteractionSourceEventArgs(Local<Object> exports) {
    SpatialInteractionSourceEventArgs::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("position").ToLocalChecked(), PositionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("velocity").ToLocalChecked(), VelocityGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("orientation").ToLocalChecked(), OrientationGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("angularVelocity").ToLocalChecked(), AngularVelocityGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("positionAccuracy").ToLocalChecked(), PositionAccuracyGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("sourcePointerPose").ToLocalChecked(), SourcePointerPoseGetter);

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



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

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

    private:

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


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

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

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





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

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

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

      try  {
        ::Platform::IBox<::Platform::Numerics::Vector3>^ result = wrapper->_instance->Position;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Vector3ToJsObject(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VelocityGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

      try  {
        ::Platform::IBox<::Platform::Numerics::Vector3>^ result = wrapper->_instance->Velocity;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Vector3ToJsObject(result->Value)) : Undefined());
        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::Spatial::SpatialInteractionSourceLocation^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<::Platform::Numerics::Quaternion>^ result = wrapper->_instance->Orientation;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(QuaternionToJsObject(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AngularVelocityGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

      try  {
        ::Platform::IBox<::Platform::Numerics::Vector3>^ result = wrapper->_instance->AngularVelocity;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Vector3ToJsObject(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PositionAccuracyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

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


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

      friend v8::Local<v8::Value> WrapSpatialInteractionSourceLocation(::Windows::UI::Input::Spatial::SpatialInteractionSourceLocation^ wintRtInstance);
      friend ::Windows::UI::Input::Spatial::SpatialInteractionSourceLocation^ UnwrapSpatialInteractionSourceLocation(Local<Value> value);
  };

  Persistent<FunctionTemplate> SpatialInteractionSourceLocation::s_constructorTemplate;

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

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

  void InitSpatialInteractionSourceLocation(Local<Object> exports) {
    SpatialInteractionSourceLocation::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "tryGetSourceLossMitigationDirection", TryGetSourceLossMitigationDirection);
            Nan::SetPrototypeMethod(localRef, "tryGetLocation", TryGetLocation);
          



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

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



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

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

    private:

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


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

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

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


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

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Perception::Spatial::SpatialCoordinateSystem^>(info[0]))
      {
        try
        {
          ::Windows::Perception::Spatial::SpatialCoordinateSystem^ arg0 = dynamic_cast<::Windows::Perception::Spatial::SpatialCoordinateSystem^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Platform::IBox<::Platform::Numerics::Vector3>^ result;
          result = wrapper->_instance->TryGetSourceLossMitigationDirection(arg0);
          info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Vector3ToJsObject(result->Value)) : Undefined());
          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 TryGetLocation(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Perception::Spatial::SpatialCoordinateSystem^>(info[0]))
      {
        try
        {
          ::Windows::Perception::Spatial::SpatialCoordinateSystem^ arg0 = dynamic_cast<::Windows::Perception::Spatial::SpatialCoordinateSystem^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::UI::Input::Spatial::SpatialInteractionSourceLocation^ result;
          result = wrapper->_instance->TryGetLocation(arg0);
          info.GetReturnValue().Set(WrapSpatialInteractionSourceLocation(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 SourceLossRiskGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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


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

      friend v8::Local<v8::Value> WrapSpatialInteractionSourceProperties(::Windows::UI::Input::Spatial::SpatialInteractionSourceProperties^ wintRtInstance);
      friend ::Windows::UI::Input::Spatial::SpatialInteractionSourceProperties^ UnwrapSpatialInteractionSourceProperties(Local<Value> value);
  };

  Persistent<FunctionTemplate> SpatialInteractionSourceProperties::s_constructorTemplate;

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

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

  void InitSpatialInteractionSourceProperties(Local<Object> exports) {
    SpatialInteractionSourceProperties::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "tryGetPointerPose", TryGetPointerPose);
            Nan::SetPrototypeMethod(localRef, "tryGetHandPose", TryGetHandPose);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isPressed").ToLocalChecked(), IsPressedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("properties").ToLocalChecked(), PropertiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("source").ToLocalChecked(), SourceGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("timestamp").ToLocalChecked(), TimestampGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("controllerProperties").ToLocalChecked(), ControllerPropertiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isGrasped").ToLocalChecked(), IsGraspedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isMenuPressed").ToLocalChecked(), IsMenuPressedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isSelectPressed").ToLocalChecked(), IsSelectPressedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("selectPressedValue").ToLocalChecked(), SelectPressedValueGetter);

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



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

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

    private:

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


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

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

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


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

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Perception::Spatial::SpatialCoordinateSystem^>(info[0]))
      {
        try
        {
          ::Windows::Perception::Spatial::SpatialCoordinateSystem^ arg0 = dynamic_cast<::Windows::Perception::Spatial::SpatialCoordinateSystem^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::UI::Input::Spatial::SpatialPointerPose^ result;
          result = wrapper->_instance->TryGetPointerPose(arg0);
          info.GetReturnValue().Set(WrapSpatialPointerPose(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 TryGetHandPose(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Perception::People::HandPose^ result;
          result = wrapper->_instance->TryGetHandPose();
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Perception.People", "HandPose", 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 IsPressedGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

      try  {
        bool result = wrapper->_instance->IsPressed;
        info.GetReturnValue().Set(Nan::New<Boolean>(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::Spatial::SpatialInteractionSourceState^>(info.This())) {
        return;
      }

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

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

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

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

      try  {
        ::Windows::UI::Input::Spatial::SpatialInteractionSource^ result = wrapper->_instance->Source;
        info.GetReturnValue().Set(WrapSpatialInteractionSource(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::Spatial::SpatialInteractionSourceState^>(info.This())) {
        return;
      }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

      friend v8::Local<v8::Value> WrapSpatialInteractionSourceState(::Windows::UI::Input::Spatial::SpatialInteractionSourceState^ wintRtInstance);
      friend ::Windows::UI::Input::Spatial::SpatialInteractionSourceState^ UnwrapSpatialInteractionSourceState(Local<Value> value);
  };

  Persistent<FunctionTemplate> SpatialInteractionSourceState::s_constructorTemplate;

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

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

  void InitSpatialInteractionSourceState(Local<Object> exports) {
    SpatialInteractionSourceState::Init(exports);
  }

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





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

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



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

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

    private:

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


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

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

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





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

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

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

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


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

      friend v8::Local<v8::Value> WrapSpatialManipulationCanceledEventArgs(::Windows::UI::Input::Spatial::SpatialManipulationCanceledEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::Spatial::SpatialManipulationCanceledEventArgs^ UnwrapSpatialManipulationCanceledEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> SpatialManipulationCanceledEventArgs::s_constructorTemplate;

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

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

  void InitSpatialManipulationCanceledEventArgs(Local<Object> exports) {
    SpatialManipulationCanceledEventArgs::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "tryGetCumulativeDelta", TryGetCumulativeDelta);
          



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

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



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

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

    private:

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


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

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

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


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

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Perception::Spatial::SpatialCoordinateSystem^>(info[0]))
      {
        try
        {
          ::Windows::Perception::Spatial::SpatialCoordinateSystem^ arg0 = dynamic_cast<::Windows::Perception::Spatial::SpatialCoordinateSystem^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::UI::Input::Spatial::SpatialManipulationDelta^ result;
          result = wrapper->_instance->TryGetCumulativeDelta(arg0);
          info.GetReturnValue().Set(WrapSpatialManipulationDelta(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 InteractionSourceKindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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


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

      friend v8::Local<v8::Value> WrapSpatialManipulationCompletedEventArgs(::Windows::UI::Input::Spatial::SpatialManipulationCompletedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::Spatial::SpatialManipulationCompletedEventArgs^ UnwrapSpatialManipulationCompletedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> SpatialManipulationCompletedEventArgs::s_constructorTemplate;

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

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

  void InitSpatialManipulationCompletedEventArgs(Local<Object> exports) {
    SpatialManipulationCompletedEventArgs::Init(exports);
  }

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





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

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



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

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

    private:

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


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

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

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





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

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

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

      try  {
        ::Platform::Numerics::Vector3 result = wrapper->_instance->Translation;
        info.GetReturnValue().Set(Vector3ToJsObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


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

      friend v8::Local<v8::Value> WrapSpatialManipulationDelta(::Windows::UI::Input::Spatial::SpatialManipulationDelta^ wintRtInstance);
      friend ::Windows::UI::Input::Spatial::SpatialManipulationDelta^ UnwrapSpatialManipulationDelta(Local<Value> value);
  };

  Persistent<FunctionTemplate> SpatialManipulationDelta::s_constructorTemplate;

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

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

  void InitSpatialManipulationDelta(Local<Object> exports) {
    SpatialManipulationDelta::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "tryGetPointerPose", TryGetPointerPose);
          



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

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



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

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

    private:

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


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

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

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


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

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Perception::Spatial::SpatialCoordinateSystem^>(info[0]))
      {
        try
        {
          ::Windows::Perception::Spatial::SpatialCoordinateSystem^ arg0 = dynamic_cast<::Windows::Perception::Spatial::SpatialCoordinateSystem^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::UI::Input::Spatial::SpatialPointerPose^ result;
          result = wrapper->_instance->TryGetPointerPose(arg0);
          info.GetReturnValue().Set(WrapSpatialPointerPose(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 InteractionSourceKindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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


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

      friend v8::Local<v8::Value> WrapSpatialManipulationStartedEventArgs(::Windows::UI::Input::Spatial::SpatialManipulationStartedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::Spatial::SpatialManipulationStartedEventArgs^ UnwrapSpatialManipulationStartedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> SpatialManipulationStartedEventArgs::s_constructorTemplate;

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

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

  void InitSpatialManipulationStartedEventArgs(Local<Object> exports) {
    SpatialManipulationStartedEventArgs::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "tryGetCumulativeDelta", TryGetCumulativeDelta);
          



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

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



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

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

    private:

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


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

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

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


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

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Perception::Spatial::SpatialCoordinateSystem^>(info[0]))
      {
        try
        {
          ::Windows::Perception::Spatial::SpatialCoordinateSystem^ arg0 = dynamic_cast<::Windows::Perception::Spatial::SpatialCoordinateSystem^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::UI::Input::Spatial::SpatialManipulationDelta^ result;
          result = wrapper->_instance->TryGetCumulativeDelta(arg0);
          info.GetReturnValue().Set(WrapSpatialManipulationDelta(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 InteractionSourceKindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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


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

      friend v8::Local<v8::Value> WrapSpatialManipulationUpdatedEventArgs(::Windows::UI::Input::Spatial::SpatialManipulationUpdatedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::Spatial::SpatialManipulationUpdatedEventArgs^ UnwrapSpatialManipulationUpdatedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> SpatialManipulationUpdatedEventArgs::s_constructorTemplate;

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

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

  void InitSpatialManipulationUpdatedEventArgs(Local<Object> exports) {
    SpatialManipulationUpdatedEventArgs::Init(exports);
  }

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





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

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



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

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

    private:

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


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

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

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





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

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

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

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


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

      friend v8::Local<v8::Value> WrapSpatialNavigationCanceledEventArgs(::Windows::UI::Input::Spatial::SpatialNavigationCanceledEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::Spatial::SpatialNavigationCanceledEventArgs^ UnwrapSpatialNavigationCanceledEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> SpatialNavigationCanceledEventArgs::s_constructorTemplate;

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

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

  void InitSpatialNavigationCanceledEventArgs(Local<Object> exports) {
    SpatialNavigationCanceledEventArgs::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("interactionSourceKind").ToLocalChecked(), InteractionSourceKindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("normalizedOffset").ToLocalChecked(), NormalizedOffsetGetter);

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



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

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

    private:

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


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

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

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





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

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

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

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

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

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

      try  {
        ::Platform::Numerics::Vector3 result = wrapper->_instance->NormalizedOffset;
        info.GetReturnValue().Set(Vector3ToJsObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


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

      friend v8::Local<v8::Value> WrapSpatialNavigationCompletedEventArgs(::Windows::UI::Input::Spatial::SpatialNavigationCompletedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::Spatial::SpatialNavigationCompletedEventArgs^ UnwrapSpatialNavigationCompletedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> SpatialNavigationCompletedEventArgs::s_constructorTemplate;

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

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

  void InitSpatialNavigationCompletedEventArgs(Local<Object> exports) {
    SpatialNavigationCompletedEventArgs::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "tryGetPointerPose", TryGetPointerPose);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("interactionSourceKind").ToLocalChecked(), InteractionSourceKindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isNavigatingX").ToLocalChecked(), IsNavigatingXGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isNavigatingY").ToLocalChecked(), IsNavigatingYGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isNavigatingZ").ToLocalChecked(), IsNavigatingZGetter);

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



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

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

    private:

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


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

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

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


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

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Perception::Spatial::SpatialCoordinateSystem^>(info[0]))
      {
        try
        {
          ::Windows::Perception::Spatial::SpatialCoordinateSystem^ arg0 = dynamic_cast<::Windows::Perception::Spatial::SpatialCoordinateSystem^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::UI::Input::Spatial::SpatialPointerPose^ result;
          result = wrapper->_instance->TryGetPointerPose(arg0);
          info.GetReturnValue().Set(WrapSpatialPointerPose(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 InteractionSourceKindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

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

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

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

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

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

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

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


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

      friend v8::Local<v8::Value> WrapSpatialNavigationStartedEventArgs(::Windows::UI::Input::Spatial::SpatialNavigationStartedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::Spatial::SpatialNavigationStartedEventArgs^ UnwrapSpatialNavigationStartedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> SpatialNavigationStartedEventArgs::s_constructorTemplate;

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

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

  void InitSpatialNavigationStartedEventArgs(Local<Object> exports) {
    SpatialNavigationStartedEventArgs::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("interactionSourceKind").ToLocalChecked(), InteractionSourceKindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("normalizedOffset").ToLocalChecked(), NormalizedOffsetGetter);

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



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

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

    private:

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


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

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

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





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

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

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

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

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

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

      try  {
        ::Platform::Numerics::Vector3 result = wrapper->_instance->NormalizedOffset;
        info.GetReturnValue().Set(Vector3ToJsObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


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

      friend v8::Local<v8::Value> WrapSpatialNavigationUpdatedEventArgs(::Windows::UI::Input::Spatial::SpatialNavigationUpdatedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::Spatial::SpatialNavigationUpdatedEventArgs^ UnwrapSpatialNavigationUpdatedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> SpatialNavigationUpdatedEventArgs::s_constructorTemplate;

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

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

  void InitSpatialNavigationUpdatedEventArgs(Local<Object> exports) {
    SpatialNavigationUpdatedEventArgs::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("forwardDirection").ToLocalChecked(), ForwardDirectionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("position").ToLocalChecked(), PositionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("upDirection").ToLocalChecked(), UpDirectionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("orientation").ToLocalChecked(), OrientationGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("positionAccuracy").ToLocalChecked(), PositionAccuracyGetter);

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



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

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

    private:

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


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

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

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





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

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

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

      try  {
        ::Platform::Numerics::Vector3 result = wrapper->_instance->ForwardDirection;
        info.GetReturnValue().Set(Vector3ToJsObject(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::Spatial::SpatialPointerInteractionSourcePose^>(info.This())) {
        return;
      }

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

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

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

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

      try  {
        ::Platform::Numerics::Vector3 result = wrapper->_instance->UpDirection;
        info.GetReturnValue().Set(Vector3ToJsObject(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::Spatial::SpatialPointerInteractionSourcePose^>(info.This())) {
        return;
      }

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

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

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

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

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


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

      friend v8::Local<v8::Value> WrapSpatialPointerInteractionSourcePose(::Windows::UI::Input::Spatial::SpatialPointerInteractionSourcePose^ wintRtInstance);
      friend ::Windows::UI::Input::Spatial::SpatialPointerInteractionSourcePose^ UnwrapSpatialPointerInteractionSourcePose(Local<Value> value);
  };

  Persistent<FunctionTemplate> SpatialPointerInteractionSourcePose::s_constructorTemplate;

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

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

  void InitSpatialPointerInteractionSourcePose(Local<Object> exports) {
    SpatialPointerInteractionSourcePose::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "tryGetInteractionSourcePose", TryGetInteractionSourcePose);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("head").ToLocalChecked(), HeadGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("timestamp").ToLocalChecked(), TimestampGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("eyes").ToLocalChecked(), EyesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isHeadCapturedBySystem").ToLocalChecked(), IsHeadCapturedBySystemGetter);

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

        Nan::SetMethod(constructor, "tryGetAtTimestamp", TryGetAtTimestamp);


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

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

    private:

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


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

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

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


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

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Spatial::SpatialInteractionSource^>(info[0]))
      {
        try
        {
          ::Windows::UI::Input::Spatial::SpatialInteractionSource^ arg0 = UnwrapSpatialInteractionSource(info[0]);
          
          ::Windows::UI::Input::Spatial::SpatialPointerInteractionSourcePose^ result;
          result = wrapper->_instance->TryGetInteractionSourcePose(arg0);
          info.GetReturnValue().Set(WrapSpatialPointerInteractionSourcePose(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 TryGetAtTimestamp(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Perception::Spatial::SpatialCoordinateSystem^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Perception::PerceptionTimestamp^>(info[1]))
      {
        try
        {
          ::Windows::Perception::Spatial::SpatialCoordinateSystem^ arg0 = dynamic_cast<::Windows::Perception::Spatial::SpatialCoordinateSystem^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Perception::PerceptionTimestamp^ arg1 = dynamic_cast<::Windows::Perception::PerceptionTimestamp^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          ::Windows::UI::Input::Spatial::SpatialPointerPose^ result;
          result = ::Windows::UI::Input::Spatial::SpatialPointerPose::TryGetAtTimestamp(arg0, arg1);
          info.GetReturnValue().Set(WrapSpatialPointerPose(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 HeadGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

      try  {
        ::Windows::Perception::People::HeadPose^ result = wrapper->_instance->Head;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Perception.People", "HeadPose", 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::Spatial::SpatialPointerPose^>(info.This())) {
        return;
      }

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

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

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

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

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

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

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

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


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

      friend v8::Local<v8::Value> WrapSpatialPointerPose(::Windows::UI::Input::Spatial::SpatialPointerPose^ wintRtInstance);
      friend ::Windows::UI::Input::Spatial::SpatialPointerPose^ UnwrapSpatialPointerPose(Local<Value> value);
  };

  Persistent<FunctionTemplate> SpatialPointerPose::s_constructorTemplate;

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

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

  void InitSpatialPointerPose(Local<Object> exports) {
    SpatialPointerPose::Init(exports);
  }

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





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

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



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

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

    private:

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


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

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

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





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

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

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

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


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

      friend v8::Local<v8::Value> WrapSpatialRecognitionEndedEventArgs(::Windows::UI::Input::Spatial::SpatialRecognitionEndedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::Spatial::SpatialRecognitionEndedEventArgs^ UnwrapSpatialRecognitionEndedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> SpatialRecognitionEndedEventArgs::s_constructorTemplate;

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

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

  void InitSpatialRecognitionEndedEventArgs(Local<Object> exports) {
    SpatialRecognitionEndedEventArgs::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "tryGetPointerPose", TryGetPointerPose);
            Nan::SetPrototypeMethod(localRef, "isGesturePossible", IsGesturePossible);
          



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

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



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

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

    private:

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


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

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

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


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

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Perception::Spatial::SpatialCoordinateSystem^>(info[0]))
      {
        try
        {
          ::Windows::Perception::Spatial::SpatialCoordinateSystem^ arg0 = dynamic_cast<::Windows::Perception::Spatial::SpatialCoordinateSystem^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::UI::Input::Spatial::SpatialPointerPose^ result;
          result = wrapper->_instance->TryGetPointerPose(arg0);
          info.GetReturnValue().Set(WrapSpatialPointerPose(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 IsGesturePossible(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::UI::Input::Spatial::SpatialGestureSettings arg0 = static_cast<::Windows::UI::Input::Spatial::SpatialGestureSettings>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          bool result;
          result = wrapper->_instance->IsGesturePossible(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 InteractionSourceKindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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


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

      friend v8::Local<v8::Value> WrapSpatialRecognitionStartedEventArgs(::Windows::UI::Input::Spatial::SpatialRecognitionStartedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::Spatial::SpatialRecognitionStartedEventArgs^ UnwrapSpatialRecognitionStartedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> SpatialRecognitionStartedEventArgs::s_constructorTemplate;

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

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

  void InitSpatialRecognitionStartedEventArgs(Local<Object> exports) {
    SpatialRecognitionStartedEventArgs::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "tryGetPointerPose", TryGetPointerPose);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("interactionSourceKind").ToLocalChecked(), InteractionSourceKindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("tapCount").ToLocalChecked(), TapCountGetter);

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



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

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

    private:

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


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

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

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


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

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Perception::Spatial::SpatialCoordinateSystem^>(info[0]))
      {
        try
        {
          ::Windows::Perception::Spatial::SpatialCoordinateSystem^ arg0 = dynamic_cast<::Windows::Perception::Spatial::SpatialCoordinateSystem^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::UI::Input::Spatial::SpatialPointerPose^ result;
          result = wrapper->_instance->TryGetPointerPose(arg0);
          info.GetReturnValue().Set(WrapSpatialPointerPose(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 InteractionSourceKindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

      try  {
        ::Windows::UI::Input::Spatial::SpatialInteractionSourceKind result = wrapper->_instance->InteractionSourceKind;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(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::Spatial::SpatialTappedEventArgs^>(info.This())) {
        return;
      }

      SpatialTappedEventArgs *wrapper = SpatialTappedEventArgs::Unwrap<SpatialTappedEventArgs>(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;
      }
    }
      


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

      friend v8::Local<v8::Value> WrapSpatialTappedEventArgs(::Windows::UI::Input::Spatial::SpatialTappedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::Spatial::SpatialTappedEventArgs^ UnwrapSpatialTappedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> SpatialTappedEventArgs::s_constructorTemplate;

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

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

  void InitSpatialTappedEventArgs(Local<Object> exports) {
    SpatialTappedEventArgs::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::Spatial::InitSpatialGestureSettingsEnum(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialInteractionPressKindEnum(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialInteractionSourceHandednessEnum(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialInteractionSourceKindEnum(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialInteractionSourcePositionAccuracyEnum(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialGestureRecognizer(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialHoldCanceledEventArgs(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialHoldCompletedEventArgs(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialHoldStartedEventArgs(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialInteraction(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialInteractionController(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialInteractionControllerProperties(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialInteractionDetectedEventArgs(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialInteractionManager(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialInteractionSource(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialInteractionSourceEventArgs(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialInteractionSourceLocation(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialInteractionSourceProperties(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialInteractionSourceState(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialManipulationCanceledEventArgs(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialManipulationCompletedEventArgs(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialManipulationDelta(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialManipulationStartedEventArgs(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialManipulationUpdatedEventArgs(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialNavigationCanceledEventArgs(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialNavigationCompletedEventArgs(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialNavigationStartedEventArgs(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialNavigationUpdatedEventArgs(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialPointerInteractionSourcePose(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialPointerPose(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialRecognitionEndedEventArgs(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialRecognitionStartedEventArgs(target);
      NodeRT::Windows::UI::Input::Spatial::InitSpatialTappedEventArgs(target);


  NodeRT::Utils::RegisterNameSpace("Windows.UI.Input.Spatial", target);
}



NODE_MODULE(binding, init)