// 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 Composition { namespace Interactions { 
  v8::Local<v8::Value> WrapCompositionConditionalValue(::Windows::UI::Composition::Interactions::CompositionConditionalValue^ wintRtInstance);
  ::Windows::UI::Composition::Interactions::CompositionConditionalValue^ UnwrapCompositionConditionalValue(Local<Value> value);
  
  v8::Local<v8::Value> WrapCompositionInteractionSourceCollection(::Windows::UI::Composition::Interactions::CompositionInteractionSourceCollection^ wintRtInstance);
  ::Windows::UI::Composition::Interactions::CompositionInteractionSourceCollection^ UnwrapCompositionInteractionSourceCollection(Local<Value> value);
  
  v8::Local<v8::Value> WrapICompositionInteractionSource(::Windows::UI::Composition::Interactions::ICompositionInteractionSource^ wintRtInstance);
  ::Windows::UI::Composition::Interactions::ICompositionInteractionSource^ UnwrapICompositionInteractionSource(Local<Value> value);
  
  v8::Local<v8::Value> WrapIInteractionTrackerOwner(::Windows::UI::Composition::Interactions::IInteractionTrackerOwner^ wintRtInstance);
  ::Windows::UI::Composition::Interactions::IInteractionTrackerOwner^ UnwrapIInteractionTrackerOwner(Local<Value> value);
  
  v8::Local<v8::Value> WrapInteractionSourceConfiguration(::Windows::UI::Composition::Interactions::InteractionSourceConfiguration^ wintRtInstance);
  ::Windows::UI::Composition::Interactions::InteractionSourceConfiguration^ UnwrapInteractionSourceConfiguration(Local<Value> value);
  
  v8::Local<v8::Value> WrapInteractionTracker(::Windows::UI::Composition::Interactions::InteractionTracker^ wintRtInstance);
  ::Windows::UI::Composition::Interactions::InteractionTracker^ UnwrapInteractionTracker(Local<Value> value);
  
  v8::Local<v8::Value> WrapInteractionTrackerCustomAnimationStateEnteredArgs(::Windows::UI::Composition::Interactions::InteractionTrackerCustomAnimationStateEnteredArgs^ wintRtInstance);
  ::Windows::UI::Composition::Interactions::InteractionTrackerCustomAnimationStateEnteredArgs^ UnwrapInteractionTrackerCustomAnimationStateEnteredArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapInteractionTrackerIdleStateEnteredArgs(::Windows::UI::Composition::Interactions::InteractionTrackerIdleStateEnteredArgs^ wintRtInstance);
  ::Windows::UI::Composition::Interactions::InteractionTrackerIdleStateEnteredArgs^ UnwrapInteractionTrackerIdleStateEnteredArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapInteractionTrackerInertiaModifier(::Windows::UI::Composition::Interactions::InteractionTrackerInertiaModifier^ wintRtInstance);
  ::Windows::UI::Composition::Interactions::InteractionTrackerInertiaModifier^ UnwrapInteractionTrackerInertiaModifier(Local<Value> value);
  
  v8::Local<v8::Value> WrapInteractionTrackerInertiaMotion(::Windows::UI::Composition::Interactions::InteractionTrackerInertiaMotion^ wintRtInstance);
  ::Windows::UI::Composition::Interactions::InteractionTrackerInertiaMotion^ UnwrapInteractionTrackerInertiaMotion(Local<Value> value);
  
  v8::Local<v8::Value> WrapInteractionTrackerInertiaNaturalMotion(::Windows::UI::Composition::Interactions::InteractionTrackerInertiaNaturalMotion^ wintRtInstance);
  ::Windows::UI::Composition::Interactions::InteractionTrackerInertiaNaturalMotion^ UnwrapInteractionTrackerInertiaNaturalMotion(Local<Value> value);
  
  v8::Local<v8::Value> WrapInteractionTrackerInertiaRestingValue(::Windows::UI::Composition::Interactions::InteractionTrackerInertiaRestingValue^ wintRtInstance);
  ::Windows::UI::Composition::Interactions::InteractionTrackerInertiaRestingValue^ UnwrapInteractionTrackerInertiaRestingValue(Local<Value> value);
  
  v8::Local<v8::Value> WrapInteractionTrackerInertiaStateEnteredArgs(::Windows::UI::Composition::Interactions::InteractionTrackerInertiaStateEnteredArgs^ wintRtInstance);
  ::Windows::UI::Composition::Interactions::InteractionTrackerInertiaStateEnteredArgs^ UnwrapInteractionTrackerInertiaStateEnteredArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapInteractionTrackerInteractingStateEnteredArgs(::Windows::UI::Composition::Interactions::InteractionTrackerInteractingStateEnteredArgs^ wintRtInstance);
  ::Windows::UI::Composition::Interactions::InteractionTrackerInteractingStateEnteredArgs^ UnwrapInteractionTrackerInteractingStateEnteredArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapInteractionTrackerRequestIgnoredArgs(::Windows::UI::Composition::Interactions::InteractionTrackerRequestIgnoredArgs^ wintRtInstance);
  ::Windows::UI::Composition::Interactions::InteractionTrackerRequestIgnoredArgs^ UnwrapInteractionTrackerRequestIgnoredArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapInteractionTrackerValuesChangedArgs(::Windows::UI::Composition::Interactions::InteractionTrackerValuesChangedArgs^ wintRtInstance);
  ::Windows::UI::Composition::Interactions::InteractionTrackerValuesChangedArgs^ UnwrapInteractionTrackerValuesChangedArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapInteractionTrackerVector2InertiaModifier(::Windows::UI::Composition::Interactions::InteractionTrackerVector2InertiaModifier^ wintRtInstance);
  ::Windows::UI::Composition::Interactions::InteractionTrackerVector2InertiaModifier^ UnwrapInteractionTrackerVector2InertiaModifier(Local<Value> value);
  
  v8::Local<v8::Value> WrapInteractionTrackerVector2InertiaNaturalMotion(::Windows::UI::Composition::Interactions::InteractionTrackerVector2InertiaNaturalMotion^ wintRtInstance);
  ::Windows::UI::Composition::Interactions::InteractionTrackerVector2InertiaNaturalMotion^ UnwrapInteractionTrackerVector2InertiaNaturalMotion(Local<Value> value);
  
  v8::Local<v8::Value> WrapVisualInteractionSource(::Windows::UI::Composition::Interactions::VisualInteractionSource^ wintRtInstance);
  ::Windows::UI::Composition::Interactions::VisualInteractionSource^ UnwrapVisualInteractionSource(Local<Value> value);
  



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

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

    Nan::Set(exports, Nan::New<String>("InteractionBindingAxisModes").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Composition::Interactions::InteractionBindingAxisModes::None)));
    Nan::Set(enumObject, Nan::New<String>("positionX").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Composition::Interactions::InteractionBindingAxisModes::PositionX)));
    Nan::Set(enumObject, Nan::New<String>("positionY").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Composition::Interactions::InteractionBindingAxisModes::PositionY)));
    Nan::Set(enumObject, Nan::New<String>("scale").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Composition::Interactions::InteractionBindingAxisModes::Scale)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("InteractionChainingMode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("auto").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Composition::Interactions::InteractionChainingMode::Auto)));
    Nan::Set(enumObject, Nan::New<String>("always").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Composition::Interactions::InteractionChainingMode::Always)));
    Nan::Set(enumObject, Nan::New<String>("never").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Composition::Interactions::InteractionChainingMode::Never)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("InteractionSourceMode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("disabled").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Composition::Interactions::InteractionSourceMode::Disabled)));
    Nan::Set(enumObject, Nan::New<String>("enabledWithInertia").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Composition::Interactions::InteractionSourceMode::EnabledWithInertia)));
    Nan::Set(enumObject, Nan::New<String>("enabledWithoutInertia").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Composition::Interactions::InteractionSourceMode::EnabledWithoutInertia)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("InteractionSourceRedirectionMode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("disabled").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Composition::Interactions::InteractionSourceRedirectionMode::Disabled)));
    Nan::Set(enumObject, Nan::New<String>("enabled").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Composition::Interactions::InteractionSourceRedirectionMode::Enabled)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("InteractionTrackerClampingOption").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("auto").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Composition::Interactions::InteractionTrackerClampingOption::Auto)));
    Nan::Set(enumObject, Nan::New<String>("disabled").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Composition::Interactions::InteractionTrackerClampingOption::Disabled)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("InteractionTrackerPositionUpdateOption").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("default").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Composition::Interactions::InteractionTrackerPositionUpdateOption::Default)));
    Nan::Set(enumObject, Nan::New<String>("allowActiveCustomScaleAnimation").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Composition::Interactions::InteractionTrackerPositionUpdateOption::AllowActiveCustomScaleAnimation)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("VisualInteractionSourceRedirectionMode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("off").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Composition::Interactions::VisualInteractionSourceRedirectionMode::Off)));
    Nan::Set(enumObject, Nan::New<String>("capableTouchpadOnly").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Composition::Interactions::VisualInteractionSourceRedirectionMode::CapableTouchpadOnly)));
    Nan::Set(enumObject, Nan::New<String>("pointerWheelOnly").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Composition::Interactions::VisualInteractionSourceRedirectionMode::PointerWheelOnly)));
    Nan::Set(enumObject, Nan::New<String>("capableTouchpadAndPointerWheel").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Composition::Interactions::VisualInteractionSourceRedirectionMode::CapableTouchpadAndPointerWheel)));
  }


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

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("value").ToLocalChecked(), ValueGetter, ValueSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("condition").ToLocalChecked(), ConditionGetter, ConditionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("compositor").ToLocalChecked(), CompositorGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("properties").ToLocalChecked(), PropertiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("implicitAnimations").ToLocalChecked(), ImplicitAnimationsGetter, ImplicitAnimationsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("comment").ToLocalChecked(), CommentGetter, CommentSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcherQueue").ToLocalChecked(), DispatcherQueueGetter);

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

        Nan::SetMethod(constructor, "create", Create);


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

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

    private:

      CompositionConditionalValue(::Windows::UI::Composition::Interactions::CompositionConditionalValue^ 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::Composition::Interactions::CompositionConditionalValue^ winRtInstance;


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

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

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





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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Compositor^>(info[0]))
      {
        try
        {
          ::Windows::UI::Composition::Compositor^ arg0 = dynamic_cast<::Windows::UI::Composition::Compositor^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::UI::Composition::Interactions::CompositionConditionalValue^ result;
          result = ::Windows::UI::Composition::Interactions::CompositionConditionalValue::Create(arg0);
          info.GetReturnValue().Set(WrapCompositionConditionalValue(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 ValueGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

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

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

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

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


    private:
      ::Windows::UI::Composition::Interactions::CompositionConditionalValue^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapCompositionConditionalValue(::Windows::UI::Composition::Interactions::CompositionConditionalValue^ wintRtInstance);
      friend ::Windows::UI::Composition::Interactions::CompositionConditionalValue^ UnwrapCompositionConditionalValue(Local<Value> value);
  };

  Persistent<FunctionTemplate> CompositionConditionalValue::s_constructorTemplate;

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

  ::Windows::UI::Composition::Interactions::CompositionConditionalValue^ UnwrapCompositionConditionalValue(Local<Value> value) {
     return CompositionConditionalValue::Unwrap<CompositionConditionalValue>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitCompositionConditionalValue(Local<Object> exports) {
    CompositionConditionalValue::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "add", Add);
            Nan::SetPrototypeMethod(localRef, "remove", Remove);
            Nan::SetPrototypeMethod(localRef, "removeAll", RemoveAll);
            Nan::SetPrototypeMethod(localRef, "first", First);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("count").ToLocalChecked(), CountGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("compositor").ToLocalChecked(), CompositorGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("properties").ToLocalChecked(), PropertiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("implicitAnimations").ToLocalChecked(), ImplicitAnimationsGetter, ImplicitAnimationsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("comment").ToLocalChecked(), CommentGetter, CommentSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcherQueue").ToLocalChecked(), DispatcherQueueGetter);

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



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

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

    private:

      CompositionInteractionSourceCollection(::Windows::UI::Composition::Interactions::CompositionInteractionSourceCollection^ 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::Composition::Interactions::CompositionInteractionSourceCollection^ winRtInstance;


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

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

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


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

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::ICompositionInteractionSource^>(info[0]))
      {
        try
        {
          ::Windows::UI::Composition::Interactions::ICompositionInteractionSource^ arg0 = UnwrapICompositionInteractionSource(info[0]);
          
          wrapper->_instance->Add(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 Remove(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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

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

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

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

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IIterator<::Windows::UI::Composition::Interactions::ICompositionInteractionSource^>^ result;
          result = wrapper->_instance->First();
          info.GetReturnValue().Set(NodeRT::Collections::IteratorWrapper<::Windows::UI::Composition::Interactions::ICompositionInteractionSource^>::CreateIteratorWrapper(result, 
            [](::Windows::UI::Composition::Interactions::ICompositionInteractionSource^ val) -> Local<Value> {
              return WrapICompositionInteractionSource(val);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

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

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

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

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


    private:
      ::Windows::UI::Composition::Interactions::CompositionInteractionSourceCollection^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapCompositionInteractionSourceCollection(::Windows::UI::Composition::Interactions::CompositionInteractionSourceCollection^ wintRtInstance);
      friend ::Windows::UI::Composition::Interactions::CompositionInteractionSourceCollection^ UnwrapCompositionInteractionSourceCollection(Local<Value> value);
  };

  Persistent<FunctionTemplate> CompositionInteractionSourceCollection::s_constructorTemplate;

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

  ::Windows::UI::Composition::Interactions::CompositionInteractionSourceCollection^ UnwrapCompositionInteractionSourceCollection(Local<Value> value) {
     return CompositionInteractionSourceCollection::Unwrap<CompositionInteractionSourceCollection>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitCompositionInteractionSourceCollection(Local<Object> exports) {
    CompositionInteractionSourceCollection::Init(exports);
  }

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






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



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

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

    private:

      ICompositionInteractionSource(::Windows::UI::Composition::Interactions::ICompositionInteractionSource^ 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::Composition::Interactions::ICompositionInteractionSource^ winRtInstance;


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

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

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







    private:
      ::Windows::UI::Composition::Interactions::ICompositionInteractionSource^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapICompositionInteractionSource(::Windows::UI::Composition::Interactions::ICompositionInteractionSource^ wintRtInstance);
      friend ::Windows::UI::Composition::Interactions::ICompositionInteractionSource^ UnwrapICompositionInteractionSource(Local<Value> value);
  };

  Persistent<FunctionTemplate> ICompositionInteractionSource::s_constructorTemplate;

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

  ::Windows::UI::Composition::Interactions::ICompositionInteractionSource^ UnwrapICompositionInteractionSource(Local<Value> value) {
     return ICompositionInteractionSource::Unwrap<ICompositionInteractionSource>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitICompositionInteractionSource(Local<Object> exports) {
    ICompositionInteractionSource::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "customAnimationStateEntered", CustomAnimationStateEntered);
            Nan::SetPrototypeMethod(localRef, "idleStateEntered", IdleStateEntered);
            Nan::SetPrototypeMethod(localRef, "inertiaStateEntered", InertiaStateEntered);
            Nan::SetPrototypeMethod(localRef, "interactingStateEntered", InteractingStateEntered);
            Nan::SetPrototypeMethod(localRef, "requestIgnored", RequestIgnored);
            Nan::SetPrototypeMethod(localRef, "valuesChanged", ValuesChanged);
          




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



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

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

    private:

      IInteractionTrackerOwner(::Windows::UI::Composition::Interactions::IInteractionTrackerOwner^ 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::Composition::Interactions::IInteractionTrackerOwner^ winRtInstance;


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

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

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


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

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

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

      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::InteractionTracker^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::InteractionTrackerCustomAnimationStateEnteredArgs^>(info[1]))
      {
        try
        {
          ::Windows::UI::Composition::Interactions::InteractionTracker^ arg0 = UnwrapInteractionTracker(info[0]);
          ::Windows::UI::Composition::Interactions::InteractionTrackerCustomAnimationStateEnteredArgs^ arg1 = UnwrapInteractionTrackerCustomAnimationStateEnteredArgs(info[1]);
          
          wrapper->_instance->CustomAnimationStateEntered(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void IdleStateEntered(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::InteractionTracker^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::InteractionTrackerIdleStateEnteredArgs^>(info[1]))
      {
        try
        {
          ::Windows::UI::Composition::Interactions::InteractionTracker^ arg0 = UnwrapInteractionTracker(info[0]);
          ::Windows::UI::Composition::Interactions::InteractionTrackerIdleStateEnteredArgs^ arg1 = UnwrapInteractionTrackerIdleStateEnteredArgs(info[1]);
          
          wrapper->_instance->IdleStateEntered(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void InertiaStateEntered(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::InteractionTracker^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::InteractionTrackerInertiaStateEnteredArgs^>(info[1]))
      {
        try
        {
          ::Windows::UI::Composition::Interactions::InteractionTracker^ arg0 = UnwrapInteractionTracker(info[0]);
          ::Windows::UI::Composition::Interactions::InteractionTrackerInertiaStateEnteredArgs^ arg1 = UnwrapInteractionTrackerInertiaStateEnteredArgs(info[1]);
          
          wrapper->_instance->InertiaStateEntered(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void InteractingStateEntered(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::InteractionTracker^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::InteractionTrackerInteractingStateEnteredArgs^>(info[1]))
      {
        try
        {
          ::Windows::UI::Composition::Interactions::InteractionTracker^ arg0 = UnwrapInteractionTracker(info[0]);
          ::Windows::UI::Composition::Interactions::InteractionTrackerInteractingStateEnteredArgs^ arg1 = UnwrapInteractionTrackerInteractingStateEnteredArgs(info[1]);
          
          wrapper->_instance->InteractingStateEntered(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void RequestIgnored(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::InteractionTracker^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::InteractionTrackerRequestIgnoredArgs^>(info[1]))
      {
        try
        {
          ::Windows::UI::Composition::Interactions::InteractionTracker^ arg0 = UnwrapInteractionTracker(info[0]);
          ::Windows::UI::Composition::Interactions::InteractionTrackerRequestIgnoredArgs^ arg1 = UnwrapInteractionTrackerRequestIgnoredArgs(info[1]);
          
          wrapper->_instance->RequestIgnored(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void ValuesChanged(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::InteractionTracker^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::InteractionTrackerValuesChangedArgs^>(info[1]))
      {
        try
        {
          ::Windows::UI::Composition::Interactions::InteractionTracker^ arg0 = UnwrapInteractionTracker(info[0]);
          ::Windows::UI::Composition::Interactions::InteractionTrackerValuesChangedArgs^ arg1 = UnwrapInteractionTrackerValuesChangedArgs(info[1]);
          
          wrapper->_instance->ValuesChanged(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





    private:
      ::Windows::UI::Composition::Interactions::IInteractionTrackerOwner^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIInteractionTrackerOwner(::Windows::UI::Composition::Interactions::IInteractionTrackerOwner^ wintRtInstance);
      friend ::Windows::UI::Composition::Interactions::IInteractionTrackerOwner^ UnwrapIInteractionTrackerOwner(Local<Value> value);
  };

  Persistent<FunctionTemplate> IInteractionTrackerOwner::s_constructorTemplate;

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

  ::Windows::UI::Composition::Interactions::IInteractionTrackerOwner^ UnwrapIInteractionTrackerOwner(Local<Value> value) {
     return IInteractionTrackerOwner::Unwrap<IInteractionTrackerOwner>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIInteractionTrackerOwner(Local<Object> exports) {
    IInteractionTrackerOwner::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("scaleSourceMode").ToLocalChecked(), ScaleSourceModeGetter, ScaleSourceModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("positionYSourceMode").ToLocalChecked(), PositionYSourceModeGetter, PositionYSourceModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("positionXSourceMode").ToLocalChecked(), PositionXSourceModeGetter, PositionXSourceModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("compositor").ToLocalChecked(), CompositorGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("properties").ToLocalChecked(), PropertiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("implicitAnimations").ToLocalChecked(), ImplicitAnimationsGetter, ImplicitAnimationsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("comment").ToLocalChecked(), CommentGetter, CommentSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcherQueue").ToLocalChecked(), DispatcherQueueGetter);

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



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

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

    private:

      InteractionSourceConfiguration(::Windows::UI::Composition::Interactions::InteractionSourceConfiguration^ 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::Composition::Interactions::InteractionSourceConfiguration^ winRtInstance;


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

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

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





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

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

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

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

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

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

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

      try {

        ::Windows::UI::Composition::Interactions::InteractionSourceRedirectionMode winRtValue = static_cast<::Windows::UI::Composition::Interactions::InteractionSourceRedirectionMode>(Nan::To<int32_t>(value).FromMaybe(0));

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

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

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

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

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

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

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

      try {

        ::Windows::UI::Composition::Interactions::InteractionSourceRedirectionMode winRtValue = static_cast<::Windows::UI::Composition::Interactions::InteractionSourceRedirectionMode>(Nan::To<int32_t>(value).FromMaybe(0));

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

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

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

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

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

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

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

      try {

        ::Windows::UI::Composition::Interactions::InteractionSourceRedirectionMode winRtValue = static_cast<::Windows::UI::Composition::Interactions::InteractionSourceRedirectionMode>(Nan::To<int32_t>(value).FromMaybe(0));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

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

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

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

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


    private:
      ::Windows::UI::Composition::Interactions::InteractionSourceConfiguration^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInteractionSourceConfiguration(::Windows::UI::Composition::Interactions::InteractionSourceConfiguration^ wintRtInstance);
      friend ::Windows::UI::Composition::Interactions::InteractionSourceConfiguration^ UnwrapInteractionSourceConfiguration(Local<Value> value);
  };

  Persistent<FunctionTemplate> InteractionSourceConfiguration::s_constructorTemplate;

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

  ::Windows::UI::Composition::Interactions::InteractionSourceConfiguration^ UnwrapInteractionSourceConfiguration(Local<Value> value) {
     return InteractionSourceConfiguration::Unwrap<InteractionSourceConfiguration>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInteractionSourceConfiguration(Local<Object> exports) {
    InteractionSourceConfiguration::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "adjustPositionXIfGreaterThanThreshold", AdjustPositionXIfGreaterThanThreshold);
            Nan::SetPrototypeMethod(localRef, "adjustPositionYIfGreaterThanThreshold", AdjustPositionYIfGreaterThanThreshold);
            Nan::SetPrototypeMethod(localRef, "configurePositionXInertiaModifiers", ConfigurePositionXInertiaModifiers);
            Nan::SetPrototypeMethod(localRef, "configurePositionYInertiaModifiers", ConfigurePositionYInertiaModifiers);
            Nan::SetPrototypeMethod(localRef, "configureScaleInertiaModifiers", ConfigureScaleInertiaModifiers);
            Nan::SetPrototypeMethod(localRef, "tryUpdatePosition", TryUpdatePosition);
            Nan::SetPrototypeMethod(localRef, "tryUpdatePositionBy", TryUpdatePositionBy);
            Nan::SetPrototypeMethod(localRef, "tryUpdatePositionWithAnimation", TryUpdatePositionWithAnimation);
            Nan::SetPrototypeMethod(localRef, "tryUpdatePositionWithAdditionalVelocity", TryUpdatePositionWithAdditionalVelocity);
            Nan::SetPrototypeMethod(localRef, "tryUpdateScale", TryUpdateScale);
            Nan::SetPrototypeMethod(localRef, "tryUpdateScaleWithAnimation", TryUpdateScaleWithAnimation);
            Nan::SetPrototypeMethod(localRef, "tryUpdateScaleWithAdditionalVelocity", TryUpdateScaleWithAdditionalVelocity);
            Nan::SetPrototypeMethod(localRef, "configureCenterPointXInertiaModifiers", ConfigureCenterPointXInertiaModifiers);
            Nan::SetPrototypeMethod(localRef, "configureCenterPointYInertiaModifiers", ConfigureCenterPointYInertiaModifiers);
            Nan::SetPrototypeMethod(localRef, "configureVector2PositionInertiaModifiers", ConfigureVector2PositionInertiaModifiers);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("scaleInertiaDecayRate").ToLocalChecked(), ScaleInertiaDecayRateGetter, ScaleInertiaDecayRateSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("positionInertiaDecayRate").ToLocalChecked(), PositionInertiaDecayRateGetter, PositionInertiaDecayRateSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("minScale").ToLocalChecked(), MinScaleGetter, MinScaleSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("minPosition").ToLocalChecked(), MinPositionGetter, MinPositionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxScale").ToLocalChecked(), MaxScaleGetter, MaxScaleSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxPosition").ToLocalChecked(), MaxPositionGetter, MaxPositionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("interactionSources").ToLocalChecked(), InteractionSourcesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isPositionRoundingSuggested").ToLocalChecked(), IsPositionRoundingSuggestedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("naturalRestingPosition").ToLocalChecked(), NaturalRestingPositionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("naturalRestingScale").ToLocalChecked(), NaturalRestingScaleGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("owner").ToLocalChecked(), OwnerGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("position").ToLocalChecked(), PositionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("positionVelocityInPixelsPerSecond").ToLocalChecked(), PositionVelocityInPixelsPerSecondGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("scale").ToLocalChecked(), ScaleGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("scaleVelocityInPercentPerSecond").ToLocalChecked(), ScaleVelocityInPercentPerSecondGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isInertiaFromImpulse").ToLocalChecked(), IsInertiaFromImpulseGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("compositor").ToLocalChecked(), CompositorGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("properties").ToLocalChecked(), PropertiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("implicitAnimations").ToLocalChecked(), ImplicitAnimationsGetter, ImplicitAnimationsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("comment").ToLocalChecked(), CommentGetter, CommentSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcherQueue").ToLocalChecked(), DispatcherQueueGetter);

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

        Nan::SetMethod(constructor, "setBindingMode", SetBindingMode);
        Nan::SetMethod(constructor, "getBindingMode", GetBindingMode);
        Nan::SetMethod(constructor, "create", Create);
        Nan::SetMethod(constructor, "createWithOwner", CreateWithOwner);


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

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

    private:

      InteractionTracker(::Windows::UI::Composition::Interactions::InteractionTracker^ 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::Composition::Interactions::InteractionTracker^ winRtInstance;


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

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

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


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

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

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

      if (info.Length() == 2
        && info[0]->IsNumber()
        && info[1]->IsNumber())
      {
        try
        {
          float arg0 = static_cast<float>(Nan::To<double>(info[0]).FromMaybe(0.0));
          float arg1 = static_cast<float>(Nan::To<double>(info[1]).FromMaybe(0.0));
          
          wrapper->_instance->AdjustPositionXIfGreaterThanThreshold(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void AdjustPositionYIfGreaterThanThreshold(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 2
        && info[0]->IsNumber()
        && info[1]->IsNumber())
      {
        try
        {
          float arg0 = static_cast<float>(Nan::To<double>(info[0]).FromMaybe(0.0));
          float arg1 = static_cast<float>(Nan::To<double>(info[1]).FromMaybe(0.0));
          
          wrapper->_instance->AdjustPositionYIfGreaterThanThreshold(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void ConfigurePositionXInertiaModifiers(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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

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

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

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

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

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

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

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

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

      if (info.Length() == 1
        && IsVector3JsObject(info[0]))
      {
        try
        {
          ::Platform::Numerics::Vector3 arg0 = Vector3FromJsObject(info[0]);
          
          int result;
          result = wrapper->_instance->TryUpdatePosition(arg0);
          info.GetReturnValue().Set(Nan::New<Integer>(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && IsVector3JsObject(info[0])
        && info[1]->IsInt32())
      {
        try
        {
          ::Platform::Numerics::Vector3 arg0 = Vector3FromJsObject(info[0]);
          ::Windows::UI::Composition::Interactions::InteractionTrackerClampingOption arg1 = static_cast<::Windows::UI::Composition::Interactions::InteractionTrackerClampingOption>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          int result;
          result = wrapper->_instance->TryUpdatePosition(arg0, arg1);
          info.GetReturnValue().Set(Nan::New<Integer>(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && IsVector3JsObject(info[0])
        && info[1]->IsInt32()
        && info[2]->IsInt32())
      {
        try
        {
          ::Platform::Numerics::Vector3 arg0 = Vector3FromJsObject(info[0]);
          ::Windows::UI::Composition::Interactions::InteractionTrackerClampingOption arg1 = static_cast<::Windows::UI::Composition::Interactions::InteractionTrackerClampingOption>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          ::Windows::UI::Composition::Interactions::InteractionTrackerPositionUpdateOption arg2 = static_cast<::Windows::UI::Composition::Interactions::InteractionTrackerPositionUpdateOption>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          
          int result;
          result = wrapper->_instance->TryUpdatePosition(arg0, arg1, arg2);
          info.GetReturnValue().Set(Nan::New<Integer>(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void TryUpdatePositionBy(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 1
        && IsVector3JsObject(info[0]))
      {
        try
        {
          ::Platform::Numerics::Vector3 arg0 = Vector3FromJsObject(info[0]);
          
          int result;
          result = wrapper->_instance->TryUpdatePositionBy(arg0);
          info.GetReturnValue().Set(Nan::New<Integer>(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && IsVector3JsObject(info[0])
        && info[1]->IsInt32())
      {
        try
        {
          ::Platform::Numerics::Vector3 arg0 = Vector3FromJsObject(info[0]);
          ::Windows::UI::Composition::Interactions::InteractionTrackerClampingOption arg1 = static_cast<::Windows::UI::Composition::Interactions::InteractionTrackerClampingOption>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          int result;
          result = wrapper->_instance->TryUpdatePositionBy(arg0, arg1);
          info.GetReturnValue().Set(Nan::New<Integer>(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void TryUpdatePositionWithAnimation(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::CompositionAnimation^>(info[0]))
      {
        try
        {
          ::Windows::UI::Composition::CompositionAnimation^ arg0 = dynamic_cast<::Windows::UI::Composition::CompositionAnimation^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          int result;
          result = wrapper->_instance->TryUpdatePositionWithAnimation(arg0);
          info.GetReturnValue().Set(Nan::New<Integer>(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void TryUpdatePositionWithAdditionalVelocity(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 1
        && IsVector3JsObject(info[0]))
      {
        try
        {
          ::Platform::Numerics::Vector3 arg0 = Vector3FromJsObject(info[0]);
          
          int result;
          result = wrapper->_instance->TryUpdatePositionWithAdditionalVelocity(arg0);
          info.GetReturnValue().Set(Nan::New<Integer>(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void TryUpdateScale(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 2
        && info[0]->IsNumber()
        && IsVector3JsObject(info[1]))
      {
        try
        {
          float arg0 = static_cast<float>(Nan::To<double>(info[0]).FromMaybe(0.0));
          ::Platform::Numerics::Vector3 arg1 = Vector3FromJsObject(info[1]);
          
          int result;
          result = wrapper->_instance->TryUpdateScale(arg0, arg1);
          info.GetReturnValue().Set(Nan::New<Integer>(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void TryUpdateScaleWithAnimation(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::CompositionAnimation^>(info[0])
        && IsVector3JsObject(info[1]))
      {
        try
        {
          ::Windows::UI::Composition::CompositionAnimation^ arg0 = dynamic_cast<::Windows::UI::Composition::CompositionAnimation^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Platform::Numerics::Vector3 arg1 = Vector3FromJsObject(info[1]);
          
          int result;
          result = wrapper->_instance->TryUpdateScaleWithAnimation(arg0, arg1);
          info.GetReturnValue().Set(Nan::New<Integer>(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void TryUpdateScaleWithAdditionalVelocity(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 2
        && info[0]->IsNumber()
        && IsVector3JsObject(info[1]))
      {
        try
        {
          float arg0 = static_cast<float>(Nan::To<double>(info[0]).FromMaybe(0.0));
          ::Platform::Numerics::Vector3 arg1 = Vector3FromJsObject(info[1]);
          
          int result;
          result = wrapper->_instance->TryUpdateScaleWithAdditionalVelocity(arg0, arg1);
          info.GetReturnValue().Set(Nan::New<Integer>(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void ConfigureCenterPointXInertiaModifiers(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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

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

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

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

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

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

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

      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::InteractionTracker^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::InteractionTracker^>(info[1])
        && info[2]->IsInt32())
      {
        try
        {
          ::Windows::UI::Composition::Interactions::InteractionTracker^ arg0 = UnwrapInteractionTracker(info[0]);
          ::Windows::UI::Composition::Interactions::InteractionTracker^ arg1 = UnwrapInteractionTracker(info[1]);
          ::Windows::UI::Composition::Interactions::InteractionBindingAxisModes arg2 = static_cast<::Windows::UI::Composition::Interactions::InteractionBindingAxisModes>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          
          ::Windows::UI::Composition::Interactions::InteractionTracker::SetBindingMode(arg0, arg1, arg2);
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

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

      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::InteractionTracker^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::InteractionTracker^>(info[1]))
      {
        try
        {
          ::Windows::UI::Composition::Interactions::InteractionTracker^ arg0 = UnwrapInteractionTracker(info[0]);
          ::Windows::UI::Composition::Interactions::InteractionTracker^ arg1 = UnwrapInteractionTracker(info[1]);
          
          ::Windows::UI::Composition::Interactions::InteractionBindingAxisModes result;
          result = ::Windows::UI::Composition::Interactions::InteractionTracker::GetBindingMode(arg0, arg1);
          info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(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 Create(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Compositor^>(info[0]))
      {
        try
        {
          ::Windows::UI::Composition::Compositor^ arg0 = dynamic_cast<::Windows::UI::Composition::Compositor^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::UI::Composition::Interactions::InteractionTracker^ result;
          result = ::Windows::UI::Composition::Interactions::InteractionTracker::Create(arg0);
          info.GetReturnValue().Set(WrapInteractionTracker(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 CreateWithOwner(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Compositor^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::IInteractionTrackerOwner^>(info[1]))
      {
        try
        {
          ::Windows::UI::Composition::Compositor^ arg0 = dynamic_cast<::Windows::UI::Composition::Compositor^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::UI::Composition::Interactions::IInteractionTrackerOwner^ arg1 = UnwrapIInteractionTrackerOwner(info[1]);
          
          ::Windows::UI::Composition::Interactions::InteractionTracker^ result;
          result = ::Windows::UI::Composition::Interactions::InteractionTracker::CreateWithOwner(arg0, arg1);
          info.GetReturnValue().Set(WrapInteractionTracker(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 ScaleInertiaDecayRateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

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

      try {

        ::Platform::IBox<float>^ winRtValue = ref new ::Platform::Box<float>(static_cast<float>(Nan::To<double>(value).FromMaybe(0.0)));

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

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

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

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

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

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

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

      try {

        ::Platform::IBox<::Platform::Numerics::Vector3>^ winRtValue = ref new ::Platform::Box<::Platform::Numerics::Vector3>(Vector3FromJsObject(value));

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

        ::Platform::Numerics::Vector3 winRtValue = Vector3FromJsObject(value);

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

        ::Platform::Numerics::Vector3 winRtValue = Vector3FromJsObject(value);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try  {
        ::Windows::UI::Composition::Interactions::IInteractionTrackerOwner^ result = wrapper->_instance->Owner;
        info.GetReturnValue().Set(WrapIInteractionTrackerOwner(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::Composition::Interactions::InteractionTracker^>(info.This())) {
        return;
      }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

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

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

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

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


    private:
      ::Windows::UI::Composition::Interactions::InteractionTracker^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInteractionTracker(::Windows::UI::Composition::Interactions::InteractionTracker^ wintRtInstance);
      friend ::Windows::UI::Composition::Interactions::InteractionTracker^ UnwrapInteractionTracker(Local<Value> value);
  };

  Persistent<FunctionTemplate> InteractionTracker::s_constructorTemplate;

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

  ::Windows::UI::Composition::Interactions::InteractionTracker^ UnwrapInteractionTracker(Local<Value> value) {
     return InteractionTracker::Unwrap<InteractionTracker>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInteractionTracker(Local<Object> exports) {
    InteractionTracker::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("requestId").ToLocalChecked(), RequestIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isFromBinding").ToLocalChecked(), IsFromBindingGetter);

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



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

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

    private:

      InteractionTrackerCustomAnimationStateEnteredArgs(::Windows::UI::Composition::Interactions::InteractionTrackerCustomAnimationStateEnteredArgs^ 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::Composition::Interactions::InteractionTrackerCustomAnimationStateEnteredArgs^ winRtInstance;


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

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

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





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

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

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

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

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

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

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


    private:
      ::Windows::UI::Composition::Interactions::InteractionTrackerCustomAnimationStateEnteredArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInteractionTrackerCustomAnimationStateEnteredArgs(::Windows::UI::Composition::Interactions::InteractionTrackerCustomAnimationStateEnteredArgs^ wintRtInstance);
      friend ::Windows::UI::Composition::Interactions::InteractionTrackerCustomAnimationStateEnteredArgs^ UnwrapInteractionTrackerCustomAnimationStateEnteredArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> InteractionTrackerCustomAnimationStateEnteredArgs::s_constructorTemplate;

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

  ::Windows::UI::Composition::Interactions::InteractionTrackerCustomAnimationStateEnteredArgs^ UnwrapInteractionTrackerCustomAnimationStateEnteredArgs(Local<Value> value) {
     return InteractionTrackerCustomAnimationStateEnteredArgs::Unwrap<InteractionTrackerCustomAnimationStateEnteredArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInteractionTrackerCustomAnimationStateEnteredArgs(Local<Object> exports) {
    InteractionTrackerCustomAnimationStateEnteredArgs::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("requestId").ToLocalChecked(), RequestIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isFromBinding").ToLocalChecked(), IsFromBindingGetter);

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



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

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

    private:

      InteractionTrackerIdleStateEnteredArgs(::Windows::UI::Composition::Interactions::InteractionTrackerIdleStateEnteredArgs^ 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::Composition::Interactions::InteractionTrackerIdleStateEnteredArgs^ winRtInstance;


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

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

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





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

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

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

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

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

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

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


    private:
      ::Windows::UI::Composition::Interactions::InteractionTrackerIdleStateEnteredArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInteractionTrackerIdleStateEnteredArgs(::Windows::UI::Composition::Interactions::InteractionTrackerIdleStateEnteredArgs^ wintRtInstance);
      friend ::Windows::UI::Composition::Interactions::InteractionTrackerIdleStateEnteredArgs^ UnwrapInteractionTrackerIdleStateEnteredArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> InteractionTrackerIdleStateEnteredArgs::s_constructorTemplate;

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

  ::Windows::UI::Composition::Interactions::InteractionTrackerIdleStateEnteredArgs^ UnwrapInteractionTrackerIdleStateEnteredArgs(Local<Value> value) {
     return InteractionTrackerIdleStateEnteredArgs::Unwrap<InteractionTrackerIdleStateEnteredArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInteractionTrackerIdleStateEnteredArgs(Local<Object> exports) {
    InteractionTrackerIdleStateEnteredArgs::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("compositor").ToLocalChecked(), CompositorGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("properties").ToLocalChecked(), PropertiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("implicitAnimations").ToLocalChecked(), ImplicitAnimationsGetter, ImplicitAnimationsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("comment").ToLocalChecked(), CommentGetter, CommentSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcherQueue").ToLocalChecked(), DispatcherQueueGetter);

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



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

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

    private:

      InteractionTrackerInertiaModifier(::Windows::UI::Composition::Interactions::InteractionTrackerInertiaModifier^ 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::Composition::Interactions::InteractionTrackerInertiaModifier^ winRtInstance;


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

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

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





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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

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

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

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

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


    private:
      ::Windows::UI::Composition::Interactions::InteractionTrackerInertiaModifier^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInteractionTrackerInertiaModifier(::Windows::UI::Composition::Interactions::InteractionTrackerInertiaModifier^ wintRtInstance);
      friend ::Windows::UI::Composition::Interactions::InteractionTrackerInertiaModifier^ UnwrapInteractionTrackerInertiaModifier(Local<Value> value);
  };

  Persistent<FunctionTemplate> InteractionTrackerInertiaModifier::s_constructorTemplate;

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

  ::Windows::UI::Composition::Interactions::InteractionTrackerInertiaModifier^ UnwrapInteractionTrackerInertiaModifier(Local<Value> value) {
     return InteractionTrackerInertiaModifier::Unwrap<InteractionTrackerInertiaModifier>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInteractionTrackerInertiaModifier(Local<Object> exports) {
    InteractionTrackerInertiaModifier::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("motion").ToLocalChecked(), MotionGetter, MotionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("condition").ToLocalChecked(), ConditionGetter, ConditionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("compositor").ToLocalChecked(), CompositorGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("properties").ToLocalChecked(), PropertiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("implicitAnimations").ToLocalChecked(), ImplicitAnimationsGetter, ImplicitAnimationsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("comment").ToLocalChecked(), CommentGetter, CommentSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcherQueue").ToLocalChecked(), DispatcherQueueGetter);

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

        Nan::SetMethod(constructor, "create", Create);


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

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

    private:

      InteractionTrackerInertiaMotion(::Windows::UI::Composition::Interactions::InteractionTrackerInertiaMotion^ 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::Composition::Interactions::InteractionTrackerInertiaMotion^ winRtInstance;


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

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

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





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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Compositor^>(info[0]))
      {
        try
        {
          ::Windows::UI::Composition::Compositor^ arg0 = dynamic_cast<::Windows::UI::Composition::Compositor^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::UI::Composition::Interactions::InteractionTrackerInertiaMotion^ result;
          result = ::Windows::UI::Composition::Interactions::InteractionTrackerInertiaMotion::Create(arg0);
          info.GetReturnValue().Set(WrapInteractionTrackerInertiaMotion(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 MotionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

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

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

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

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


    private:
      ::Windows::UI::Composition::Interactions::InteractionTrackerInertiaMotion^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInteractionTrackerInertiaMotion(::Windows::UI::Composition::Interactions::InteractionTrackerInertiaMotion^ wintRtInstance);
      friend ::Windows::UI::Composition::Interactions::InteractionTrackerInertiaMotion^ UnwrapInteractionTrackerInertiaMotion(Local<Value> value);
  };

  Persistent<FunctionTemplate> InteractionTrackerInertiaMotion::s_constructorTemplate;

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

  ::Windows::UI::Composition::Interactions::InteractionTrackerInertiaMotion^ UnwrapInteractionTrackerInertiaMotion(Local<Value> value) {
     return InteractionTrackerInertiaMotion::Unwrap<InteractionTrackerInertiaMotion>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInteractionTrackerInertiaMotion(Local<Object> exports) {
    InteractionTrackerInertiaMotion::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("naturalMotion").ToLocalChecked(), NaturalMotionGetter, NaturalMotionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("condition").ToLocalChecked(), ConditionGetter, ConditionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("compositor").ToLocalChecked(), CompositorGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("properties").ToLocalChecked(), PropertiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("implicitAnimations").ToLocalChecked(), ImplicitAnimationsGetter, ImplicitAnimationsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("comment").ToLocalChecked(), CommentGetter, CommentSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcherQueue").ToLocalChecked(), DispatcherQueueGetter);

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

        Nan::SetMethod(constructor, "create", Create);


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

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

    private:

      InteractionTrackerInertiaNaturalMotion(::Windows::UI::Composition::Interactions::InteractionTrackerInertiaNaturalMotion^ 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::Composition::Interactions::InteractionTrackerInertiaNaturalMotion^ winRtInstance;


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

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

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





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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Compositor^>(info[0]))
      {
        try
        {
          ::Windows::UI::Composition::Compositor^ arg0 = dynamic_cast<::Windows::UI::Composition::Compositor^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::UI::Composition::Interactions::InteractionTrackerInertiaNaturalMotion^ result;
          result = ::Windows::UI::Composition::Interactions::InteractionTrackerInertiaNaturalMotion::Create(arg0);
          info.GetReturnValue().Set(WrapInteractionTrackerInertiaNaturalMotion(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 NaturalMotionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

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

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

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

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


    private:
      ::Windows::UI::Composition::Interactions::InteractionTrackerInertiaNaturalMotion^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInteractionTrackerInertiaNaturalMotion(::Windows::UI::Composition::Interactions::InteractionTrackerInertiaNaturalMotion^ wintRtInstance);
      friend ::Windows::UI::Composition::Interactions::InteractionTrackerInertiaNaturalMotion^ UnwrapInteractionTrackerInertiaNaturalMotion(Local<Value> value);
  };

  Persistent<FunctionTemplate> InteractionTrackerInertiaNaturalMotion::s_constructorTemplate;

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

  ::Windows::UI::Composition::Interactions::InteractionTrackerInertiaNaturalMotion^ UnwrapInteractionTrackerInertiaNaturalMotion(Local<Value> value) {
     return InteractionTrackerInertiaNaturalMotion::Unwrap<InteractionTrackerInertiaNaturalMotion>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInteractionTrackerInertiaNaturalMotion(Local<Object> exports) {
    InteractionTrackerInertiaNaturalMotion::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("restingValue").ToLocalChecked(), RestingValueGetter, RestingValueSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("condition").ToLocalChecked(), ConditionGetter, ConditionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("compositor").ToLocalChecked(), CompositorGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("properties").ToLocalChecked(), PropertiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("implicitAnimations").ToLocalChecked(), ImplicitAnimationsGetter, ImplicitAnimationsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("comment").ToLocalChecked(), CommentGetter, CommentSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcherQueue").ToLocalChecked(), DispatcherQueueGetter);

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

        Nan::SetMethod(constructor, "create", Create);


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

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

    private:

      InteractionTrackerInertiaRestingValue(::Windows::UI::Composition::Interactions::InteractionTrackerInertiaRestingValue^ 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::Composition::Interactions::InteractionTrackerInertiaRestingValue^ winRtInstance;


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

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

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





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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Compositor^>(info[0]))
      {
        try
        {
          ::Windows::UI::Composition::Compositor^ arg0 = dynamic_cast<::Windows::UI::Composition::Compositor^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::UI::Composition::Interactions::InteractionTrackerInertiaRestingValue^ result;
          result = ::Windows::UI::Composition::Interactions::InteractionTrackerInertiaRestingValue::Create(arg0);
          info.GetReturnValue().Set(WrapInteractionTrackerInertiaRestingValue(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 RestingValueGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

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

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

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

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


    private:
      ::Windows::UI::Composition::Interactions::InteractionTrackerInertiaRestingValue^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInteractionTrackerInertiaRestingValue(::Windows::UI::Composition::Interactions::InteractionTrackerInertiaRestingValue^ wintRtInstance);
      friend ::Windows::UI::Composition::Interactions::InteractionTrackerInertiaRestingValue^ UnwrapInteractionTrackerInertiaRestingValue(Local<Value> value);
  };

  Persistent<FunctionTemplate> InteractionTrackerInertiaRestingValue::s_constructorTemplate;

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

  ::Windows::UI::Composition::Interactions::InteractionTrackerInertiaRestingValue^ UnwrapInteractionTrackerInertiaRestingValue(Local<Value> value) {
     return InteractionTrackerInertiaRestingValue::Unwrap<InteractionTrackerInertiaRestingValue>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInteractionTrackerInertiaRestingValue(Local<Object> exports) {
    InteractionTrackerInertiaRestingValue::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("modifiedRestingPosition").ToLocalChecked(), ModifiedRestingPositionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("modifiedRestingScale").ToLocalChecked(), ModifiedRestingScaleGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("naturalRestingPosition").ToLocalChecked(), NaturalRestingPositionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("naturalRestingScale").ToLocalChecked(), NaturalRestingScaleGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("positionVelocityInPixelsPerSecond").ToLocalChecked(), PositionVelocityInPixelsPerSecondGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("requestId").ToLocalChecked(), RequestIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("scaleVelocityInPercentPerSecond").ToLocalChecked(), ScaleVelocityInPercentPerSecondGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isInertiaFromImpulse").ToLocalChecked(), IsInertiaFromImpulseGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isFromBinding").ToLocalChecked(), IsFromBindingGetter);

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



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

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

    private:

      InteractionTrackerInertiaStateEnteredArgs(::Windows::UI::Composition::Interactions::InteractionTrackerInertiaStateEnteredArgs^ 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::Composition::Interactions::InteractionTrackerInertiaStateEnteredArgs^ winRtInstance;


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

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

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





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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


    private:
      ::Windows::UI::Composition::Interactions::InteractionTrackerInertiaStateEnteredArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInteractionTrackerInertiaStateEnteredArgs(::Windows::UI::Composition::Interactions::InteractionTrackerInertiaStateEnteredArgs^ wintRtInstance);
      friend ::Windows::UI::Composition::Interactions::InteractionTrackerInertiaStateEnteredArgs^ UnwrapInteractionTrackerInertiaStateEnteredArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> InteractionTrackerInertiaStateEnteredArgs::s_constructorTemplate;

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

  ::Windows::UI::Composition::Interactions::InteractionTrackerInertiaStateEnteredArgs^ UnwrapInteractionTrackerInertiaStateEnteredArgs(Local<Value> value) {
     return InteractionTrackerInertiaStateEnteredArgs::Unwrap<InteractionTrackerInertiaStateEnteredArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInteractionTrackerInertiaStateEnteredArgs(Local<Object> exports) {
    InteractionTrackerInertiaStateEnteredArgs::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("requestId").ToLocalChecked(), RequestIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isFromBinding").ToLocalChecked(), IsFromBindingGetter);

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



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

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

    private:

      InteractionTrackerInteractingStateEnteredArgs(::Windows::UI::Composition::Interactions::InteractionTrackerInteractingStateEnteredArgs^ 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::Composition::Interactions::InteractionTrackerInteractingStateEnteredArgs^ winRtInstance;


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

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

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





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

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

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

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

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

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

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


    private:
      ::Windows::UI::Composition::Interactions::InteractionTrackerInteractingStateEnteredArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInteractionTrackerInteractingStateEnteredArgs(::Windows::UI::Composition::Interactions::InteractionTrackerInteractingStateEnteredArgs^ wintRtInstance);
      friend ::Windows::UI::Composition::Interactions::InteractionTrackerInteractingStateEnteredArgs^ UnwrapInteractionTrackerInteractingStateEnteredArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> InteractionTrackerInteractingStateEnteredArgs::s_constructorTemplate;

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

  ::Windows::UI::Composition::Interactions::InteractionTrackerInteractingStateEnteredArgs^ UnwrapInteractionTrackerInteractingStateEnteredArgs(Local<Value> value) {
     return InteractionTrackerInteractingStateEnteredArgs::Unwrap<InteractionTrackerInteractingStateEnteredArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInteractionTrackerInteractingStateEnteredArgs(Local<Object> exports) {
    InteractionTrackerInteractingStateEnteredArgs::Init(exports);
  }

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





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

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



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

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

    private:

      InteractionTrackerRequestIgnoredArgs(::Windows::UI::Composition::Interactions::InteractionTrackerRequestIgnoredArgs^ 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::Composition::Interactions::InteractionTrackerRequestIgnoredArgs^ winRtInstance;


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

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

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





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

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

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

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


    private:
      ::Windows::UI::Composition::Interactions::InteractionTrackerRequestIgnoredArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInteractionTrackerRequestIgnoredArgs(::Windows::UI::Composition::Interactions::InteractionTrackerRequestIgnoredArgs^ wintRtInstance);
      friend ::Windows::UI::Composition::Interactions::InteractionTrackerRequestIgnoredArgs^ UnwrapInteractionTrackerRequestIgnoredArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> InteractionTrackerRequestIgnoredArgs::s_constructorTemplate;

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

  ::Windows::UI::Composition::Interactions::InteractionTrackerRequestIgnoredArgs^ UnwrapInteractionTrackerRequestIgnoredArgs(Local<Value> value) {
     return InteractionTrackerRequestIgnoredArgs::Unwrap<InteractionTrackerRequestIgnoredArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInteractionTrackerRequestIgnoredArgs(Local<Object> exports) {
    InteractionTrackerRequestIgnoredArgs::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("position").ToLocalChecked(), PositionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("requestId").ToLocalChecked(), RequestIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("scale").ToLocalChecked(), ScaleGetter);

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



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

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

    private:

      InteractionTrackerValuesChangedArgs(::Windows::UI::Composition::Interactions::InteractionTrackerValuesChangedArgs^ 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::Composition::Interactions::InteractionTrackerValuesChangedArgs^ winRtInstance;


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

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

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





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

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

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

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

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

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

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

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

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


    private:
      ::Windows::UI::Composition::Interactions::InteractionTrackerValuesChangedArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInteractionTrackerValuesChangedArgs(::Windows::UI::Composition::Interactions::InteractionTrackerValuesChangedArgs^ wintRtInstance);
      friend ::Windows::UI::Composition::Interactions::InteractionTrackerValuesChangedArgs^ UnwrapInteractionTrackerValuesChangedArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> InteractionTrackerValuesChangedArgs::s_constructorTemplate;

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

  ::Windows::UI::Composition::Interactions::InteractionTrackerValuesChangedArgs^ UnwrapInteractionTrackerValuesChangedArgs(Local<Value> value) {
     return InteractionTrackerValuesChangedArgs::Unwrap<InteractionTrackerValuesChangedArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInteractionTrackerValuesChangedArgs(Local<Object> exports) {
    InteractionTrackerValuesChangedArgs::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("compositor").ToLocalChecked(), CompositorGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("properties").ToLocalChecked(), PropertiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("implicitAnimations").ToLocalChecked(), ImplicitAnimationsGetter, ImplicitAnimationsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("comment").ToLocalChecked(), CommentGetter, CommentSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcherQueue").ToLocalChecked(), DispatcherQueueGetter);

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



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

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

    private:

      InteractionTrackerVector2InertiaModifier(::Windows::UI::Composition::Interactions::InteractionTrackerVector2InertiaModifier^ 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::Composition::Interactions::InteractionTrackerVector2InertiaModifier^ winRtInstance;


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

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

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





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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

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

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

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

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


    private:
      ::Windows::UI::Composition::Interactions::InteractionTrackerVector2InertiaModifier^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInteractionTrackerVector2InertiaModifier(::Windows::UI::Composition::Interactions::InteractionTrackerVector2InertiaModifier^ wintRtInstance);
      friend ::Windows::UI::Composition::Interactions::InteractionTrackerVector2InertiaModifier^ UnwrapInteractionTrackerVector2InertiaModifier(Local<Value> value);
  };

  Persistent<FunctionTemplate> InteractionTrackerVector2InertiaModifier::s_constructorTemplate;

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

  ::Windows::UI::Composition::Interactions::InteractionTrackerVector2InertiaModifier^ UnwrapInteractionTrackerVector2InertiaModifier(Local<Value> value) {
     return InteractionTrackerVector2InertiaModifier::Unwrap<InteractionTrackerVector2InertiaModifier>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInteractionTrackerVector2InertiaModifier(Local<Object> exports) {
    InteractionTrackerVector2InertiaModifier::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("naturalMotion").ToLocalChecked(), NaturalMotionGetter, NaturalMotionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("condition").ToLocalChecked(), ConditionGetter, ConditionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("compositor").ToLocalChecked(), CompositorGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("properties").ToLocalChecked(), PropertiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("implicitAnimations").ToLocalChecked(), ImplicitAnimationsGetter, ImplicitAnimationsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("comment").ToLocalChecked(), CommentGetter, CommentSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcherQueue").ToLocalChecked(), DispatcherQueueGetter);

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

        Nan::SetMethod(constructor, "create", Create);


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

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

    private:

      InteractionTrackerVector2InertiaNaturalMotion(::Windows::UI::Composition::Interactions::InteractionTrackerVector2InertiaNaturalMotion^ 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::Composition::Interactions::InteractionTrackerVector2InertiaNaturalMotion^ winRtInstance;


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

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

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





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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Compositor^>(info[0]))
      {
        try
        {
          ::Windows::UI::Composition::Compositor^ arg0 = dynamic_cast<::Windows::UI::Composition::Compositor^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::UI::Composition::Interactions::InteractionTrackerVector2InertiaNaturalMotion^ result;
          result = ::Windows::UI::Composition::Interactions::InteractionTrackerVector2InertiaNaturalMotion::Create(arg0);
          info.GetReturnValue().Set(WrapInteractionTrackerVector2InertiaNaturalMotion(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 NaturalMotionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

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

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

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

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


    private:
      ::Windows::UI::Composition::Interactions::InteractionTrackerVector2InertiaNaturalMotion^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInteractionTrackerVector2InertiaNaturalMotion(::Windows::UI::Composition::Interactions::InteractionTrackerVector2InertiaNaturalMotion^ wintRtInstance);
      friend ::Windows::UI::Composition::Interactions::InteractionTrackerVector2InertiaNaturalMotion^ UnwrapInteractionTrackerVector2InertiaNaturalMotion(Local<Value> value);
  };

  Persistent<FunctionTemplate> InteractionTrackerVector2InertiaNaturalMotion::s_constructorTemplate;

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

  ::Windows::UI::Composition::Interactions::InteractionTrackerVector2InertiaNaturalMotion^ UnwrapInteractionTrackerVector2InertiaNaturalMotion(Local<Value> value) {
     return InteractionTrackerVector2InertiaNaturalMotion::Unwrap<InteractionTrackerVector2InertiaNaturalMotion>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInteractionTrackerVector2InertiaNaturalMotion(Local<Object> exports) {
    InteractionTrackerVector2InertiaNaturalMotion::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "tryRedirectForManipulation", TryRedirectForManipulation);
            Nan::SetPrototypeMethod(localRef, "configureCenterPointXModifiers", ConfigureCenterPointXModifiers);
            Nan::SetPrototypeMethod(localRef, "configureCenterPointYModifiers", ConfigureCenterPointYModifiers);
            Nan::SetPrototypeMethod(localRef, "configureDeltaPositionXModifiers", ConfigureDeltaPositionXModifiers);
            Nan::SetPrototypeMethod(localRef, "configureDeltaPositionYModifiers", ConfigureDeltaPositionYModifiers);
            Nan::SetPrototypeMethod(localRef, "configureDeltaScaleModifiers", ConfigureDeltaScaleModifiers);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("scaleSourceMode").ToLocalChecked(), ScaleSourceModeGetter, ScaleSourceModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("scaleChainingMode").ToLocalChecked(), ScaleChainingModeGetter, ScaleChainingModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("positionYSourceMode").ToLocalChecked(), PositionYSourceModeGetter, PositionYSourceModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("positionYChainingMode").ToLocalChecked(), PositionYChainingModeGetter, PositionYChainingModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("positionXSourceMode").ToLocalChecked(), PositionXSourceModeGetter, PositionXSourceModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("positionXChainingMode").ToLocalChecked(), PositionXChainingModeGetter, PositionXChainingModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("manipulationRedirectionMode").ToLocalChecked(), ManipulationRedirectionModeGetter, ManipulationRedirectionModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isPositionYRailsEnabled").ToLocalChecked(), IsPositionYRailsEnabledGetter, IsPositionYRailsEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isPositionXRailsEnabled").ToLocalChecked(), IsPositionXRailsEnabledGetter, IsPositionXRailsEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("source").ToLocalChecked(), SourceGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("deltaPosition").ToLocalChecked(), DeltaPositionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("deltaScale").ToLocalChecked(), DeltaScaleGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("position").ToLocalChecked(), PositionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("positionVelocity").ToLocalChecked(), PositionVelocityGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("scale").ToLocalChecked(), ScaleGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("scaleVelocity").ToLocalChecked(), ScaleVelocityGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pointerWheelConfig").ToLocalChecked(), PointerWheelConfigGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("compositor").ToLocalChecked(), CompositorGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcher").ToLocalChecked(), DispatcherGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("properties").ToLocalChecked(), PropertiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("implicitAnimations").ToLocalChecked(), ImplicitAnimationsGetter, ImplicitAnimationsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("comment").ToLocalChecked(), CommentGetter, CommentSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dispatcherQueue").ToLocalChecked(), DispatcherQueueGetter);

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

        Nan::SetMethod(constructor, "createFromIVisualElement", CreateFromIVisualElement);
        Nan::SetMethod(constructor, "create", Create);


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

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

    private:

      VisualInteractionSource(::Windows::UI::Composition::Interactions::VisualInteractionSource^ 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::Composition::Interactions::VisualInteractionSource^ winRtInstance;


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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::IVisualElement^>(info[0]))
      {
        try
        {
          ::Windows::UI::Composition::IVisualElement^ arg0 = dynamic_cast<::Windows::UI::Composition::IVisualElement^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::UI::Composition::Interactions::VisualInteractionSource^ result;
          result = ::Windows::UI::Composition::Interactions::VisualInteractionSource::CreateFromIVisualElement(arg0);
          info.GetReturnValue().Set(WrapVisualInteractionSource(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 Create(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Visual^>(info[0]))
      {
        try
        {
          ::Windows::UI::Composition::Visual^ arg0 = dynamic_cast<::Windows::UI::Composition::Visual^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::UI::Composition::Interactions::VisualInteractionSource^ result;
          result = ::Windows::UI::Composition::Interactions::VisualInteractionSource::Create(arg0);
          info.GetReturnValue().Set(WrapVisualInteractionSource(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 ScaleSourceModeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

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

      try {

        ::Windows::UI::Composition::Interactions::InteractionSourceMode winRtValue = static_cast<::Windows::UI::Composition::Interactions::InteractionSourceMode>(Nan::To<int32_t>(value).FromMaybe(0));

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

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

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

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

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

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

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

      try {

        ::Windows::UI::Composition::Interactions::InteractionChainingMode winRtValue = static_cast<::Windows::UI::Composition::Interactions::InteractionChainingMode>(Nan::To<int32_t>(value).FromMaybe(0));

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

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

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

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

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

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

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

      try {

        ::Windows::UI::Composition::Interactions::InteractionSourceMode winRtValue = static_cast<::Windows::UI::Composition::Interactions::InteractionSourceMode>(Nan::To<int32_t>(value).FromMaybe(0));

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

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

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

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

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

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

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

      try {

        ::Windows::UI::Composition::Interactions::InteractionChainingMode winRtValue = static_cast<::Windows::UI::Composition::Interactions::InteractionChainingMode>(Nan::To<int32_t>(value).FromMaybe(0));

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

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

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

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

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

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

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

      try {

        ::Windows::UI::Composition::Interactions::InteractionSourceMode winRtValue = static_cast<::Windows::UI::Composition::Interactions::InteractionSourceMode>(Nan::To<int32_t>(value).FromMaybe(0));

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

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

      VisualInteractionSource *wrapper = VisualInteractionSource::Unwrap<VisualInteractionSource>(info.This());

      try  {
        ::Windows::UI::Composition::Interactions::InteractionChainingMode result = wrapper->_instance->PositionXChainingMode;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PositionXChainingModeSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::VisualInteractionSource^>(info.This())) {
        return;
      }

      VisualInteractionSource *wrapper = VisualInteractionSource::Unwrap<VisualInteractionSource>(info.This());

      try {

        ::Windows::UI::Composition::Interactions::InteractionChainingMode winRtValue = static_cast<::Windows::UI::Composition::Interactions::InteractionChainingMode>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->PositionXChainingMode = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ManipulationRedirectionModeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::VisualInteractionSource^>(info.This())) {
        return;
      }

      VisualInteractionSource *wrapper = VisualInteractionSource::Unwrap<VisualInteractionSource>(info.This());

      try  {
        ::Windows::UI::Composition::Interactions::VisualInteractionSourceRedirectionMode result = wrapper->_instance->ManipulationRedirectionMode;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ManipulationRedirectionModeSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::VisualInteractionSource^>(info.This())) {
        return;
      }

      VisualInteractionSource *wrapper = VisualInteractionSource::Unwrap<VisualInteractionSource>(info.This());

      try {

        ::Windows::UI::Composition::Interactions::VisualInteractionSourceRedirectionMode winRtValue = static_cast<::Windows::UI::Composition::Interactions::VisualInteractionSourceRedirectionMode>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->ManipulationRedirectionMode = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsPositionYRailsEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::VisualInteractionSource^>(info.This())) {
        return;
      }

      VisualInteractionSource *wrapper = VisualInteractionSource::Unwrap<VisualInteractionSource>(info.This());

      try  {
        bool result = wrapper->_instance->IsPositionYRailsEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsPositionYRailsEnabledSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::VisualInteractionSource^>(info.This())) {
        return;
      }

      VisualInteractionSource *wrapper = VisualInteractionSource::Unwrap<VisualInteractionSource>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsPositionYRailsEnabled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsPositionXRailsEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::VisualInteractionSource^>(info.This())) {
        return;
      }

      VisualInteractionSource *wrapper = VisualInteractionSource::Unwrap<VisualInteractionSource>(info.This());

      try  {
        bool result = wrapper->_instance->IsPositionXRailsEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsPositionXRailsEnabledSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::VisualInteractionSource^>(info.This())) {
        return;
      }

      VisualInteractionSource *wrapper = VisualInteractionSource::Unwrap<VisualInteractionSource>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsPositionXRailsEnabled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void SourceGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::VisualInteractionSource^>(info.This())) {
        return;
      }

      VisualInteractionSource *wrapper = VisualInteractionSource::Unwrap<VisualInteractionSource>(info.This());

      try  {
        ::Windows::UI::Composition::Visual^ result = wrapper->_instance->Source;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Composition", "Visual", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DeltaPositionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::VisualInteractionSource^>(info.This())) {
        return;
      }

      VisualInteractionSource *wrapper = VisualInteractionSource::Unwrap<VisualInteractionSource>(info.This());

      try  {
        ::Platform::Numerics::Vector3 result = wrapper->_instance->DeltaPosition;
        info.GetReturnValue().Set(Vector3ToJsObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DeltaScaleGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::VisualInteractionSource^>(info.This())) {
        return;
      }

      VisualInteractionSource *wrapper = VisualInteractionSource::Unwrap<VisualInteractionSource>(info.This());

      try  {
        float result = wrapper->_instance->DeltaScale;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PositionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::VisualInteractionSource^>(info.This())) {
        return;
      }

      VisualInteractionSource *wrapper = VisualInteractionSource::Unwrap<VisualInteractionSource>(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 PositionVelocityGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::VisualInteractionSource^>(info.This())) {
        return;
      }

      VisualInteractionSource *wrapper = VisualInteractionSource::Unwrap<VisualInteractionSource>(info.This());

      try  {
        ::Platform::Numerics::Vector3 result = wrapper->_instance->PositionVelocity;
        info.GetReturnValue().Set(Vector3ToJsObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ScaleGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::VisualInteractionSource^>(info.This())) {
        return;
      }

      VisualInteractionSource *wrapper = VisualInteractionSource::Unwrap<VisualInteractionSource>(info.This());

      try  {
        float result = wrapper->_instance->Scale;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ScaleVelocityGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::VisualInteractionSource^>(info.This())) {
        return;
      }

      VisualInteractionSource *wrapper = VisualInteractionSource::Unwrap<VisualInteractionSource>(info.This());

      try  {
        float result = wrapper->_instance->ScaleVelocity;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PointerWheelConfigGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::Interactions::VisualInteractionSource^>(info.This())) {
        return;
      }

      VisualInteractionSource *wrapper = VisualInteractionSource::Unwrap<VisualInteractionSource>(info.This());

      try  {
        ::Windows::UI::Composition::Interactions::InteractionSourceConfiguration^ result = wrapper->_instance->PointerWheelConfig;
        info.GetReturnValue().Set(WrapInteractionSourceConfiguration(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CompositorGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::CompositionObject^>(info.This())) {
        return;
      }

      CompositionObject *wrapper = CompositionObject::Unwrap<CompositionObject>(info.This());

      try  {
        ::Windows::UI::Composition::Compositor^ result = wrapper->_instance->Compositor;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Composition", "Compositor", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DispatcherGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::CompositionObject^>(info.This())) {
        return;
      }

      CompositionObject *wrapper = CompositionObject::Unwrap<CompositionObject>(info.This());

      try  {
        ::Windows::UI::Core::CoreDispatcher^ result = wrapper->_instance->Dispatcher;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "CoreDispatcher", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PropertiesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::CompositionObject^>(info.This())) {
        return;
      }

      CompositionObject *wrapper = CompositionObject::Unwrap<CompositionObject>(info.This());

      try  {
        ::Windows::UI::Composition::CompositionPropertySet^ result = wrapper->_instance->Properties;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Composition", "CompositionPropertySet", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ImplicitAnimationsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::CompositionObject^>(info.This())) {
        return;
      }

      CompositionObject *wrapper = CompositionObject::Unwrap<CompositionObject>(info.This());

      try  {
        ::Windows::UI::Composition::ImplicitAnimationCollection^ result = wrapper->_instance->ImplicitAnimations;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Composition", "ImplicitAnimationCollection", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ImplicitAnimationsSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::ImplicitAnimationCollection^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::CompositionObject^>(info.This())) {
        return;
      }

      CompositionObject *wrapper = CompositionObject::Unwrap<CompositionObject>(info.This());

      try {

        ::Windows::UI::Composition::ImplicitAnimationCollection^ winRtValue = dynamic_cast<::Windows::UI::Composition::ImplicitAnimationCollection^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->ImplicitAnimations = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void CommentGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::CompositionObject^>(info.This())) {
        return;
      }

      CompositionObject *wrapper = CompositionObject::Unwrap<CompositionObject>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Comment;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CommentSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsString()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::CompositionObject^>(info.This())) {
        return;
      }

      CompositionObject *wrapper = CompositionObject::Unwrap<CompositionObject>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->Comment = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void DispatcherQueueGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Composition::CompositionObject^>(info.This())) {
        return;
      }

      CompositionObject *wrapper = CompositionObject::Unwrap<CompositionObject>(info.This());

      try  {
        ::Windows::System::DispatcherQueue^ result = wrapper->_instance->DispatcherQueue;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.System", "DispatcherQueue", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Composition::Interactions::VisualInteractionSource^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVisualInteractionSource(::Windows::UI::Composition::Interactions::VisualInteractionSource^ wintRtInstance);
      friend ::Windows::UI::Composition::Interactions::VisualInteractionSource^ UnwrapVisualInteractionSource(Local<Value> value);
  };

  Persistent<FunctionTemplate> VisualInteractionSource::s_constructorTemplate;

  v8::Local<v8::Value> WrapVisualInteractionSource(::Windows::UI::Composition::Interactions::VisualInteractionSource^ 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>(VisualInteractionSource::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Composition::Interactions::VisualInteractionSource^ UnwrapVisualInteractionSource(Local<Value> value) {
     return VisualInteractionSource::Unwrap<VisualInteractionSource>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVisualInteractionSource(Local<Object> exports) {
    VisualInteractionSource::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::Composition::Interactions::InitInteractionBindingAxisModesEnum(target);
      NodeRT::Windows::UI::Composition::Interactions::InitInteractionChainingModeEnum(target);
      NodeRT::Windows::UI::Composition::Interactions::InitInteractionSourceModeEnum(target);
      NodeRT::Windows::UI::Composition::Interactions::InitInteractionSourceRedirectionModeEnum(target);
      NodeRT::Windows::UI::Composition::Interactions::InitInteractionTrackerClampingOptionEnum(target);
      NodeRT::Windows::UI::Composition::Interactions::InitInteractionTrackerPositionUpdateOptionEnum(target);
      NodeRT::Windows::UI::Composition::Interactions::InitVisualInteractionSourceRedirectionModeEnum(target);
      NodeRT::Windows::UI::Composition::Interactions::InitCompositionConditionalValue(target);
      NodeRT::Windows::UI::Composition::Interactions::InitCompositionInteractionSourceCollection(target);
      NodeRT::Windows::UI::Composition::Interactions::InitICompositionInteractionSource(target);
      NodeRT::Windows::UI::Composition::Interactions::InitIInteractionTrackerOwner(target);
      NodeRT::Windows::UI::Composition::Interactions::InitInteractionSourceConfiguration(target);
      NodeRT::Windows::UI::Composition::Interactions::InitInteractionTracker(target);
      NodeRT::Windows::UI::Composition::Interactions::InitInteractionTrackerCustomAnimationStateEnteredArgs(target);
      NodeRT::Windows::UI::Composition::Interactions::InitInteractionTrackerIdleStateEnteredArgs(target);
      NodeRT::Windows::UI::Composition::Interactions::InitInteractionTrackerInertiaModifier(target);
      NodeRT::Windows::UI::Composition::Interactions::InitInteractionTrackerInertiaMotion(target);
      NodeRT::Windows::UI::Composition::Interactions::InitInteractionTrackerInertiaNaturalMotion(target);
      NodeRT::Windows::UI::Composition::Interactions::InitInteractionTrackerInertiaRestingValue(target);
      NodeRT::Windows::UI::Composition::Interactions::InitInteractionTrackerInertiaStateEnteredArgs(target);
      NodeRT::Windows::UI::Composition::Interactions::InitInteractionTrackerInteractingStateEnteredArgs(target);
      NodeRT::Windows::UI::Composition::Interactions::InitInteractionTrackerRequestIgnoredArgs(target);
      NodeRT::Windows::UI::Composition::Interactions::InitInteractionTrackerValuesChangedArgs(target);
      NodeRT::Windows::UI::Composition::Interactions::InitInteractionTrackerVector2InertiaModifier(target);
      NodeRT::Windows::UI::Composition::Interactions::InitInteractionTrackerVector2InertiaNaturalMotion(target);
      NodeRT::Windows::UI::Composition::Interactions::InitVisualInteractionSource(target);


  NodeRT::Utils::RegisterNameSpace("Windows.UI.Composition.Interactions", target);
}



NODE_MODULE(binding, init)