// 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>
#include <windowsnumerics.h>

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

const char* REGISTRATION_TOKEN_MAP_PROPERTY_NAME = "__registrationTokenMap__";

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

namespace NodeRT { namespace Windows { namespace UI { namespace Input { namespace Inking { 
  v8::Local<v8::Value> WrapIInkPointFactory(::Windows::UI::Input::Inking::IInkPointFactory^ wintRtInstance);
  ::Windows::UI::Input::Inking::IInkPointFactory^ UnwrapIInkPointFactory(Local<Value> value);
  
  v8::Local<v8::Value> WrapIInkPresenterRulerFactory(::Windows::UI::Input::Inking::IInkPresenterRulerFactory^ wintRtInstance);
  ::Windows::UI::Input::Inking::IInkPresenterRulerFactory^ UnwrapIInkPresenterRulerFactory(Local<Value> value);
  
  v8::Local<v8::Value> WrapIInkPresenterStencil(::Windows::UI::Input::Inking::IInkPresenterStencil^ wintRtInstance);
  ::Windows::UI::Input::Inking::IInkPresenterStencil^ UnwrapIInkPresenterStencil(Local<Value> value);
  
  v8::Local<v8::Value> WrapIInkRecognizerContainer(::Windows::UI::Input::Inking::IInkRecognizerContainer^ wintRtInstance);
  ::Windows::UI::Input::Inking::IInkRecognizerContainer^ UnwrapIInkRecognizerContainer(Local<Value> value);
  
  v8::Local<v8::Value> WrapIInkStrokeContainer(::Windows::UI::Input::Inking::IInkStrokeContainer^ wintRtInstance);
  ::Windows::UI::Input::Inking::IInkStrokeContainer^ UnwrapIInkStrokeContainer(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkDrawingAttributes(::Windows::UI::Input::Inking::InkDrawingAttributes^ wintRtInstance);
  ::Windows::UI::Input::Inking::InkDrawingAttributes^ UnwrapInkDrawingAttributes(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkDrawingAttributesPencilProperties(::Windows::UI::Input::Inking::InkDrawingAttributesPencilProperties^ wintRtInstance);
  ::Windows::UI::Input::Inking::InkDrawingAttributesPencilProperties^ UnwrapInkDrawingAttributesPencilProperties(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkInputConfiguration(::Windows::UI::Input::Inking::InkInputConfiguration^ wintRtInstance);
  ::Windows::UI::Input::Inking::InkInputConfiguration^ UnwrapInkInputConfiguration(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkInputProcessingConfiguration(::Windows::UI::Input::Inking::InkInputProcessingConfiguration^ wintRtInstance);
  ::Windows::UI::Input::Inking::InkInputProcessingConfiguration^ UnwrapInkInputProcessingConfiguration(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkManager(::Windows::UI::Input::Inking::InkManager^ wintRtInstance);
  ::Windows::UI::Input::Inking::InkManager^ UnwrapInkManager(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkModelerAttributes(::Windows::UI::Input::Inking::InkModelerAttributes^ wintRtInstance);
  ::Windows::UI::Input::Inking::InkModelerAttributes^ UnwrapInkModelerAttributes(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkPoint(::Windows::UI::Input::Inking::InkPoint^ wintRtInstance);
  ::Windows::UI::Input::Inking::InkPoint^ UnwrapInkPoint(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkPresenter(::Windows::UI::Input::Inking::InkPresenter^ wintRtInstance);
  ::Windows::UI::Input::Inking::InkPresenter^ UnwrapInkPresenter(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkPresenterProtractor(::Windows::UI::Input::Inking::InkPresenterProtractor^ wintRtInstance);
  ::Windows::UI::Input::Inking::InkPresenterProtractor^ UnwrapInkPresenterProtractor(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkPresenterRuler(::Windows::UI::Input::Inking::InkPresenterRuler^ wintRtInstance);
  ::Windows::UI::Input::Inking::InkPresenterRuler^ UnwrapInkPresenterRuler(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkRecognitionResult(::Windows::UI::Input::Inking::InkRecognitionResult^ wintRtInstance);
  ::Windows::UI::Input::Inking::InkRecognitionResult^ UnwrapInkRecognitionResult(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkRecognizer(::Windows::UI::Input::Inking::InkRecognizer^ wintRtInstance);
  ::Windows::UI::Input::Inking::InkRecognizer^ UnwrapInkRecognizer(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkRecognizerContainer(::Windows::UI::Input::Inking::InkRecognizerContainer^ wintRtInstance);
  ::Windows::UI::Input::Inking::InkRecognizerContainer^ UnwrapInkRecognizerContainer(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkStroke(::Windows::UI::Input::Inking::InkStroke^ wintRtInstance);
  ::Windows::UI::Input::Inking::InkStroke^ UnwrapInkStroke(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkStrokeBuilder(::Windows::UI::Input::Inking::InkStrokeBuilder^ wintRtInstance);
  ::Windows::UI::Input::Inking::InkStrokeBuilder^ UnwrapInkStrokeBuilder(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkStrokeContainer(::Windows::UI::Input::Inking::InkStrokeContainer^ wintRtInstance);
  ::Windows::UI::Input::Inking::InkStrokeContainer^ UnwrapInkStrokeContainer(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkStrokeInput(::Windows::UI::Input::Inking::InkStrokeInput^ wintRtInstance);
  ::Windows::UI::Input::Inking::InkStrokeInput^ UnwrapInkStrokeInput(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkStrokeRenderingSegment(::Windows::UI::Input::Inking::InkStrokeRenderingSegment^ wintRtInstance);
  ::Windows::UI::Input::Inking::InkStrokeRenderingSegment^ UnwrapInkStrokeRenderingSegment(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkStrokesCollectedEventArgs(::Windows::UI::Input::Inking::InkStrokesCollectedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::Inking::InkStrokesCollectedEventArgs^ UnwrapInkStrokesCollectedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkStrokesErasedEventArgs(::Windows::UI::Input::Inking::InkStrokesErasedEventArgs^ wintRtInstance);
  ::Windows::UI::Input::Inking::InkStrokesErasedEventArgs^ UnwrapInkStrokesErasedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkSynchronizer(::Windows::UI::Input::Inking::InkSynchronizer^ wintRtInstance);
  ::Windows::UI::Input::Inking::InkSynchronizer^ UnwrapInkSynchronizer(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkUnprocessedInput(::Windows::UI::Input::Inking::InkUnprocessedInput^ wintRtInstance);
  ::Windows::UI::Input::Inking::InkUnprocessedInput^ UnwrapInkUnprocessedInput(Local<Value> value);
  
  v8::Local<v8::Value> WrapPenAndInkSettings(::Windows::UI::Input::Inking::PenAndInkSettings^ wintRtInstance);
  ::Windows::UI::Input::Inking::PenAndInkSettings^ UnwrapPenAndInkSettings(Local<Value> value);
  



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

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

    Nan::Set(exports, Nan::New<String>("HandwritingLineHeight").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("small").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::HandwritingLineHeight::Small)));
    Nan::Set(enumObject, Nan::New<String>("medium").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::HandwritingLineHeight::Medium)));
    Nan::Set(enumObject, Nan::New<String>("large").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::HandwritingLineHeight::Large)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("InkDrawingAttributesKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("default").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::InkDrawingAttributesKind::Default)));
    Nan::Set(enumObject, Nan::New<String>("pencil").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::InkDrawingAttributesKind::Pencil)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("InkHighContrastAdjustment").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("useSystemColorsWhenNecessary").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::InkHighContrastAdjustment::UseSystemColorsWhenNecessary)));
    Nan::Set(enumObject, Nan::New<String>("useSystemColors").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::InkHighContrastAdjustment::UseSystemColors)));
    Nan::Set(enumObject, Nan::New<String>("useOriginalColors").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::InkHighContrastAdjustment::UseOriginalColors)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("InkInputProcessingMode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::InkInputProcessingMode::None)));
    Nan::Set(enumObject, Nan::New<String>("inking").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::InkInputProcessingMode::Inking)));
    Nan::Set(enumObject, Nan::New<String>("erasing").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::InkInputProcessingMode::Erasing)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("InkInputRightDragAction").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("leaveUnprocessed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::InkInputRightDragAction::LeaveUnprocessed)));
    Nan::Set(enumObject, Nan::New<String>("allowProcessing").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::InkInputRightDragAction::AllowProcessing)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("InkManipulationMode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("inking").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::InkManipulationMode::Inking)));
    Nan::Set(enumObject, Nan::New<String>("erasing").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::InkManipulationMode::Erasing)));
    Nan::Set(enumObject, Nan::New<String>("selecting").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::InkManipulationMode::Selecting)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("InkPersistenceFormat").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("gifWithEmbeddedIsf").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::InkPersistenceFormat::GifWithEmbeddedIsf)));
    Nan::Set(enumObject, Nan::New<String>("isf").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::InkPersistenceFormat::Isf)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("InkPresenterPredefinedConfiguration").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("simpleSinglePointer").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::InkPresenterPredefinedConfiguration::SimpleSinglePointer)));
    Nan::Set(enumObject, Nan::New<String>("simpleMultiplePointer").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::InkPresenterPredefinedConfiguration::SimpleMultiplePointer)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("InkPresenterStencilKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("other").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::InkPresenterStencilKind::Other)));
    Nan::Set(enumObject, Nan::New<String>("ruler").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::InkPresenterStencilKind::Ruler)));
    Nan::Set(enumObject, Nan::New<String>("protractor").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::InkPresenterStencilKind::Protractor)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("InkRecognitionTarget").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("all").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::InkRecognitionTarget::All)));
    Nan::Set(enumObject, Nan::New<String>("selected").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::InkRecognitionTarget::Selected)));
    Nan::Set(enumObject, Nan::New<String>("recent").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::InkRecognitionTarget::Recent)));
  }

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

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

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

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

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

    Nan::Set(exports, Nan::New<String>("PenTipShape").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("circle").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::PenTipShape::Circle)));
    Nan::Set(enumObject, Nan::New<String>("rectangle").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::PenTipShape::Rectangle)));
  }


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

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

    return true;
  }

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

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

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

    return returnValue;
  }

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

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


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

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

    return true;
  }

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

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

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

    return returnValue;
  }

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

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


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

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

    symbol = Nan::New<String>("m11").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("m12").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("m21").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("m22").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("m31").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("m32").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    return true;
  }

  ::Windows::Foundation::Numerics::float3x2 Matrix3x2FromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::Foundation::Numerics::float3x2 returnValue;

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

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

    symbol = Nan::New<String>("m11").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.m11 = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("m12").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.m12 = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("m21").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.m21 = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("m22").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.m22 = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("m31").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.m31 = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("m32").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.m32 = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    return returnValue;
  }

  Local<Value> Matrix3x2ToJsObject(::Windows::Foundation::Numerics::float3x2 value) {
    EscapableHandleScope scope;

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

    Nan::Set(obj, Nan::New<String>("m11").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.m11)));
    Nan::Set(obj, Nan::New<String>("m12").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.m12)));
    Nan::Set(obj, Nan::New<String>("m21").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.m21)));
    Nan::Set(obj, Nan::New<String>("m22").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.m22)));
    Nan::Set(obj, Nan::New<String>("m31").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.m31)));
    Nan::Set(obj, Nan::New<String>("m32").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.m32)));

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

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

    return true;
  }

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

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

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

    return returnValue;
  }

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

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


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

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

    return true;
  }

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

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

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

    return returnValue;
  }

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

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


    return scope.Escape(obj);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "createInkPoint", CreateInkPoint);
          




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



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

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

    private:

      IInkPointFactory(::Windows::UI::Input::Inking::IInkPointFactory^ instance) {
        _instance = instance;
      }

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

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

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

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

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

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

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

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

      ::Windows::UI::Input::Inking::IInkPointFactory^ winRtInstance;


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

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

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


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

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

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


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

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

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

      if (info.Length() == 2
        && NodeRT::Utils::IsPoint(info[0])
        && info[1]->IsNumber())
      {
        try
        {
          ::Windows::Foundation::Point arg0 = NodeRT::Utils::PointFromJs(info[0]);
          float arg1 = static_cast<float>(Nan::To<double>(info[1]).FromMaybe(0.0));
          
          ::Windows::UI::Input::Inking::InkPoint^ result;
          result = wrapper->_instance->CreateInkPoint(arg0, arg1);
          info.GetReturnValue().Set(WrapInkPoint(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





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

      friend v8::Local<v8::Value> WrapIInkPointFactory(::Windows::UI::Input::Inking::IInkPointFactory^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::IInkPointFactory^ UnwrapIInkPointFactory(Local<Value> value);
  };

  Persistent<FunctionTemplate> IInkPointFactory::s_constructorTemplate;

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

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

  void InitIInkPointFactory(Local<Object> exports) {
    IInkPointFactory::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "create", Create);
          




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



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

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

    private:

      IInkPresenterRulerFactory(::Windows::UI::Input::Inking::IInkPresenterRulerFactory^ instance) {
        _instance = instance;
      }

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

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

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

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

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

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

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

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

      ::Windows::UI::Input::Inking::IInkPresenterRulerFactory^ winRtInstance;


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

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

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


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

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

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


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

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenter^>(info[0]))
      {
        try
        {
          ::Windows::UI::Input::Inking::InkPresenter^ arg0 = UnwrapInkPresenter(info[0]);
          
          ::Windows::UI::Input::Inking::InkPresenterRuler^ result;
          result = wrapper->_instance->Create(arg0);
          info.GetReturnValue().Set(WrapInkPresenterRuler(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





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

      friend v8::Local<v8::Value> WrapIInkPresenterRulerFactory(::Windows::UI::Input::Inking::IInkPresenterRulerFactory^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::IInkPresenterRulerFactory^ UnwrapIInkPresenterRulerFactory(Local<Value> value);
  };

  Persistent<FunctionTemplate> IInkPresenterRulerFactory::s_constructorTemplate;

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

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

  void InitIInkPresenterRulerFactory(Local<Object> exports) {
    IInkPresenterRulerFactory::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("backgroundColor").ToLocalChecked(), BackgroundColorGetter, BackgroundColorSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("foregroundColor").ToLocalChecked(), ForegroundColorGetter, ForegroundColorSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isVisible").ToLocalChecked(), IsVisibleGetter, IsVisibleSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("transform").ToLocalChecked(), TransformGetter, TransformSetter);

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



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

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

    private:

      IInkPresenterStencil(::Windows::UI::Input::Inking::IInkPresenterStencil^ instance) {
        _instance = instance;
      }

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

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

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

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

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

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

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

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

      ::Windows::UI::Input::Inking::IInkPresenterStencil^ winRtInstance;


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

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

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


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

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

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





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

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

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

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

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

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

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

      try {

        ::Windows::UI::Color winRtValue = NodeRT::Utils::ColorFromJs(value);

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

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

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

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

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

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

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

      try {

        ::Windows::UI::Color winRtValue = NodeRT::Utils::ColorFromJs(value);

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

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

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

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

      try {

        ::Windows::Foundation::Numerics::float3x2 winRtValue = Matrix3x2FromJsObject(value);

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


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

      friend v8::Local<v8::Value> WrapIInkPresenterStencil(::Windows::UI::Input::Inking::IInkPresenterStencil^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::IInkPresenterStencil^ UnwrapIInkPresenterStencil(Local<Value> value);
  };

  Persistent<FunctionTemplate> IInkPresenterStencil::s_constructorTemplate;

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

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

  void InitIInkPresenterStencil(Local<Object> exports) {
    IInkPresenterStencil::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "setDefaultRecognizer", SetDefaultRecognizer);
            Nan::SetPrototypeMethod(localRef, "getRecognizers", GetRecognizers);
          

          
            Nan::SetPrototypeMethod(localRef, "recognizeAsync", RecognizeAsync);
          



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



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

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

    private:

      IInkRecognizerContainer(::Windows::UI::Input::Inking::IInkRecognizerContainer^ instance) {
        _instance = instance;
      }

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

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

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

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

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

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

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

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

      ::Windows::UI::Input::Inking::IInkRecognizerContainer^ winRtInstance;


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

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

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


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

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

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

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

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

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::InkRecognitionResult^>^>^ op;


      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeContainer^>(info[0])
        && info[1]->IsInt32())
      {
        try
        {
          ::Windows::UI::Input::Inking::InkStrokeContainer^ arg0 = UnwrapInkStrokeContainer(info[0]);
          ::Windows::UI::Input::Inking::InkRecognitionTarget arg1 = static_cast<::Windows::UI::Input::Inking::InkRecognitionTarget>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          op = wrapper->_instance->RecognizeAsync(arg0,arg1);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

      opTask.then( [asyncToken] (task<::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::InkRecognitionResult^>^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::InkRecognitionResult^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::InkRecognitionResult^ val) -> Local<Value> {
              return WrapInkRecognitionResult(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkRecognitionResult^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::InkRecognitionResult^ {
              return UnwrapInkRecognitionResult(value);
            }
          );
              if (tryCatch.HasCaught())
              {
                error = Nan::To<Object>(tryCatch.Exception()).ToLocalChecked();
              }
              else
              {
                error = Undefined();
              }
              if (arg1.IsEmpty()) arg1 = Undefined();
            }
            Local<Value> args[] = {error, arg1};


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

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

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

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

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

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

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::InkRecognizer^>^ result;
          result = wrapper->_instance->GetRecognizers();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::InkRecognizer^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::InkRecognizer^ val) -> Local<Value> {
              return WrapInkRecognizer(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkRecognizer^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::InkRecognizer^ {
              return UnwrapInkRecognizer(value);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





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

      friend v8::Local<v8::Value> WrapIInkRecognizerContainer(::Windows::UI::Input::Inking::IInkRecognizerContainer^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::IInkRecognizerContainer^ UnwrapIInkRecognizerContainer(Local<Value> value);
  };

  Persistent<FunctionTemplate> IInkRecognizerContainer::s_constructorTemplate;

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

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

  void InitIInkRecognizerContainer(Local<Object> exports) {
    IInkRecognizerContainer::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "addStroke", AddStroke);
            Nan::SetPrototypeMethod(localRef, "deleteSelected", DeleteSelected);
            Nan::SetPrototypeMethod(localRef, "moveSelected", MoveSelected);
            Nan::SetPrototypeMethod(localRef, "selectWithPolyLine", SelectWithPolyLine);
            Nan::SetPrototypeMethod(localRef, "selectWithLine", SelectWithLine);
            Nan::SetPrototypeMethod(localRef, "copySelectedToClipboard", CopySelectedToClipboard);
            Nan::SetPrototypeMethod(localRef, "pasteFromClipboard", PasteFromClipboard);
            Nan::SetPrototypeMethod(localRef, "canPasteFromClipboard", CanPasteFromClipboard);
            Nan::SetPrototypeMethod(localRef, "updateRecognitionResults", UpdateRecognitionResults);
            Nan::SetPrototypeMethod(localRef, "getStrokes", GetStrokes);
            Nan::SetPrototypeMethod(localRef, "getRecognitionResults", GetRecognitionResults);
          

          
            Nan::SetPrototypeMethod(localRef, "loadAsync", LoadAsync);
            Nan::SetPrototypeMethod(localRef, "saveAsync", SaveAsync);
          


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

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



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

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

    private:

      IInkStrokeContainer(::Windows::UI::Input::Inking::IInkStrokeContainer^ instance) {
        _instance = instance;
      }

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

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

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

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

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

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

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

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

      ::Windows::UI::Input::Inking::IInkStrokeContainer^ winRtInstance;


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

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

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


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

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

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

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

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

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

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

      ::Windows::Foundation::IAsyncActionWithProgress<unsigned __int64>^ op;


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

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

      opTask.then( [asyncToken] (task<void> t) {
        try {
          t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> args[] = {Undefined()};


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

            Local<Value> args[] = {error};
            invokeCallback(_countof(args), args);
          });
        }
      });
    }
    static void SaveAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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

      ::Windows::Foundation::IAsyncOperationWithProgress<unsigned int, unsigned int>^ op;


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

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

      opTask.then( [asyncToken] (task<unsigned int> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = Nan::New<Integer>(result);
              if (tryCatch.HasCaught())
              {
                error = Nan::To<Object>(tryCatch.Exception()).ToLocalChecked();
              }
              else
              {
                error = Undefined();
              }
              if (arg1.IsEmpty()) arg1 = Undefined();
            }
            Local<Value> args[] = {error, arg1};


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

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

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

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

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

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

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

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

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

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsPoint(info[0]))
      {
        try
        {
          ::Windows::Foundation::Point arg0 = NodeRT::Utils::PointFromJs(info[0]);
          
          ::Windows::Foundation::Rect result;
          result = wrapper->_instance->MoveSelected(arg0);
          info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void SelectWithPolyLine(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Point>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Point>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Point>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Foundation::Point>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsPoint(value);
                 },
                 [](Local<Value> value) -> ::Windows::Foundation::Point {
                   return NodeRT::Utils::PointFromJs(value);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Point>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          ::Windows::Foundation::Rect result;
          result = wrapper->_instance->SelectWithPolyLine(arg0);
          info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void SelectWithLine(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 2
        && NodeRT::Utils::IsPoint(info[0])
        && NodeRT::Utils::IsPoint(info[1]))
      {
        try
        {
          ::Windows::Foundation::Point arg0 = NodeRT::Utils::PointFromJs(info[0]);
          ::Windows::Foundation::Point arg1 = NodeRT::Utils::PointFromJs(info[1]);
          
          ::Windows::Foundation::Rect result;
          result = wrapper->_instance->SelectWithLine(arg0, arg1);
          info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void CopySelectedToClipboard(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsPoint(info[0]))
      {
        try
        {
          ::Windows::Foundation::Point arg0 = NodeRT::Utils::PointFromJs(info[0]);
          
          ::Windows::Foundation::Rect result;
          result = wrapper->_instance->PasteFromClipboard(arg0);
          info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void CanPasteFromClipboard(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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

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

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

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

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::InkStroke^>^ result;
          result = wrapper->_instance->GetStrokes();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::InkStroke^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::InkStroke^ val) -> Local<Value> {
              return WrapInkStroke(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStroke^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::InkStroke^ {
              return UnwrapInkStroke(value);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetRecognitionResults(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::InkRecognitionResult^>^ result;
          result = wrapper->_instance->GetRecognitionResults();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::InkRecognitionResult^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::InkRecognitionResult^ val) -> Local<Value> {
              return WrapInkRecognitionResult(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkRecognitionResult^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::InkRecognitionResult^ {
              return UnwrapInkRecognitionResult(value);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



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

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

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

      try  {
        ::Windows::Foundation::Rect result = wrapper->_instance->BoundingRect;
        info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


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

      friend v8::Local<v8::Value> WrapIInkStrokeContainer(::Windows::UI::Input::Inking::IInkStrokeContainer^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::IInkStrokeContainer^ UnwrapIInkStrokeContainer(Local<Value> value);
  };

  Persistent<FunctionTemplate> IInkStrokeContainer::s_constructorTemplate;

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

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

  void InitIInkStrokeContainer(Local<Object> exports) {
    IInkStrokeContainer::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("size").ToLocalChecked(), SizeGetter, SizeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("penTip").ToLocalChecked(), PenTipGetter, PenTipSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("ignorePressure").ToLocalChecked(), IgnorePressureGetter, IgnorePressureSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("fitToCurve").ToLocalChecked(), FitToCurveGetter, FitToCurveSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("color").ToLocalChecked(), ColorGetter, ColorSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("penTipTransform").ToLocalChecked(), PenTipTransformGetter, PenTipTransformSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("drawAsHighlighter").ToLocalChecked(), DrawAsHighlighterGetter, DrawAsHighlighterSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pencilProperties").ToLocalChecked(), PencilPropertiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("ignoreTilt").ToLocalChecked(), IgnoreTiltGetter, IgnoreTiltSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("modelerAttributes").ToLocalChecked(), ModelerAttributesGetter);

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

        Nan::SetMethod(constructor, "createForPencil", CreateForPencil);


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

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

    private:

      InkDrawingAttributes(::Windows::UI::Input::Inking::InkDrawingAttributes^ instance) {
        _instance = instance;
      }

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

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

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

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

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

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

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

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

      ::Windows::UI::Input::Inking::InkDrawingAttributes^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkDrawingAttributes^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::Inking::InkDrawingAttributes^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Input::Inking::InkDrawingAttributes();
        } 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());

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

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


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

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

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





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

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

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

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

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

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

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

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

      try {

        ::Windows::Foundation::Size winRtValue = NodeRT::Utils::SizeFromJs(value);

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

        ::Windows::UI::Color winRtValue = NodeRT::Utils::ColorFromJs(value);

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

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

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

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

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

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

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

      try {

        ::Windows::Foundation::Numerics::float3x2 winRtValue = Matrix3x2FromJsObject(value);

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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


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

      friend v8::Local<v8::Value> WrapInkDrawingAttributes(::Windows::UI::Input::Inking::InkDrawingAttributes^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::InkDrawingAttributes^ UnwrapInkDrawingAttributes(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkDrawingAttributes::s_constructorTemplate;

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

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

  void InitInkDrawingAttributes(Local<Object> exports) {
    InkDrawingAttributes::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("opacity").ToLocalChecked(), OpacityGetter, OpacitySetter);

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



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

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

    private:

      InkDrawingAttributesPencilProperties(::Windows::UI::Input::Inking::InkDrawingAttributesPencilProperties^ instance) {
        _instance = instance;
      }

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

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

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

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

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

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

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

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

      ::Windows::UI::Input::Inking::InkDrawingAttributesPencilProperties^ winRtInstance;


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

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

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


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

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

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





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

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

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

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

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

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

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

      try {

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

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


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

      friend v8::Local<v8::Value> WrapInkDrawingAttributesPencilProperties(::Windows::UI::Input::Inking::InkDrawingAttributesPencilProperties^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::InkDrawingAttributesPencilProperties^ UnwrapInkDrawingAttributesPencilProperties(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkDrawingAttributesPencilProperties::s_constructorTemplate;

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

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

  void InitInkDrawingAttributesPencilProperties(Local<Object> exports) {
    InkDrawingAttributesPencilProperties::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isPrimaryBarrelButtonInputEnabled").ToLocalChecked(), IsPrimaryBarrelButtonInputEnabledGetter, IsPrimaryBarrelButtonInputEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isEraserInputEnabled").ToLocalChecked(), IsEraserInputEnabledGetter, IsEraserInputEnabledSetter);

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



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

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

    private:

      InkInputConfiguration(::Windows::UI::Input::Inking::InkInputConfiguration^ instance) {
        _instance = instance;
      }

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

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

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

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

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

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

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

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

      ::Windows::UI::Input::Inking::InkInputConfiguration^ winRtInstance;


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

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

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


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

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

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





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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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


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

      friend v8::Local<v8::Value> WrapInkInputConfiguration(::Windows::UI::Input::Inking::InkInputConfiguration^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::InkInputConfiguration^ UnwrapInkInputConfiguration(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkInputConfiguration::s_constructorTemplate;

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

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

  void InitInkInputConfiguration(Local<Object> exports) {
    InkInputConfiguration::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("rightDragAction").ToLocalChecked(), RightDragActionGetter, RightDragActionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("mode").ToLocalChecked(), ModeGetter, ModeSetter);

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



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

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

    private:

      InkInputProcessingConfiguration(::Windows::UI::Input::Inking::InkInputProcessingConfiguration^ instance) {
        _instance = instance;
      }

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

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

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

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

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

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

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

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

      ::Windows::UI::Input::Inking::InkInputProcessingConfiguration^ winRtInstance;


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

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

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


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

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

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





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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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


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

      friend v8::Local<v8::Value> WrapInkInputProcessingConfiguration(::Windows::UI::Input::Inking::InkInputProcessingConfiguration^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::InkInputProcessingConfiguration^ UnwrapInkInputProcessingConfiguration(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkInputProcessingConfiguration::s_constructorTemplate;

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

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

  void InitInkInputProcessingConfiguration(Local<Object> exports) {
    InkInputProcessingConfiguration::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "processPointerDown", ProcessPointerDown);
            Nan::SetPrototypeMethod(localRef, "processPointerUpdate", ProcessPointerUpdate);
            Nan::SetPrototypeMethod(localRef, "processPointerUp", ProcessPointerUp);
            Nan::SetPrototypeMethod(localRef, "setDefaultDrawingAttributes", SetDefaultDrawingAttributes);
            Nan::SetPrototypeMethod(localRef, "addStroke", AddStroke);
            Nan::SetPrototypeMethod(localRef, "deleteSelected", DeleteSelected);
            Nan::SetPrototypeMethod(localRef, "moveSelected", MoveSelected);
            Nan::SetPrototypeMethod(localRef, "selectWithPolyLine", SelectWithPolyLine);
            Nan::SetPrototypeMethod(localRef, "selectWithLine", SelectWithLine);
            Nan::SetPrototypeMethod(localRef, "copySelectedToClipboard", CopySelectedToClipboard);
            Nan::SetPrototypeMethod(localRef, "pasteFromClipboard", PasteFromClipboard);
            Nan::SetPrototypeMethod(localRef, "canPasteFromClipboard", CanPasteFromClipboard);
            Nan::SetPrototypeMethod(localRef, "updateRecognitionResults", UpdateRecognitionResults);
            Nan::SetPrototypeMethod(localRef, "getStrokes", GetStrokes);
            Nan::SetPrototypeMethod(localRef, "getRecognitionResults", GetRecognitionResults);
            Nan::SetPrototypeMethod(localRef, "setDefaultRecognizer", SetDefaultRecognizer);
            Nan::SetPrototypeMethod(localRef, "getRecognizers", GetRecognizers);
          

          
            Nan::SetPrototypeMethod(localRef, "recognizeAsync", RecognizeAsync);
            Nan::SetPrototypeMethod(localRef, "loadAsync", LoadAsync);
            Nan::SetPrototypeMethod(localRef, "saveAsync", SaveAsync);
          


          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("mode").ToLocalChecked(), ModeGetter, ModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("boundingRect").ToLocalChecked(), BoundingRectGetter);

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



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

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

    private:

      InkManager(::Windows::UI::Input::Inking::InkManager^ instance) {
        _instance = instance;
      }

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

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

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

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

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

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

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

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

      ::Windows::UI::Input::Inking::InkManager^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkManager^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::Inking::InkManager^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Input::Inking::InkManager();
        } 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());

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

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


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

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

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

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

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

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::InkRecognitionResult^>^>^ op;


      if (info.Length() == 2
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::UI::Input::Inking::InkRecognitionTarget arg0 = static_cast<::Windows::UI::Input::Inking::InkRecognitionTarget>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          op = wrapper->_instance->RecognizeAsync(arg0);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeContainer^>(info[0])
        && info[1]->IsInt32())
      {
        try
        {
          ::Windows::UI::Input::Inking::InkStrokeContainer^ arg0 = UnwrapInkStrokeContainer(info[0]);
          ::Windows::UI::Input::Inking::InkRecognitionTarget arg1 = static_cast<::Windows::UI::Input::Inking::InkRecognitionTarget>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          op = wrapper->_instance->RecognizeAsync(arg0,arg1);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

      opTask.then( [asyncToken] (task<::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::InkRecognitionResult^>^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::InkRecognitionResult^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::InkRecognitionResult^ val) -> Local<Value> {
              return WrapInkRecognitionResult(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkRecognitionResult^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::InkRecognitionResult^ {
              return UnwrapInkRecognitionResult(value);
            }
          );
              if (tryCatch.HasCaught())
              {
                error = Nan::To<Object>(tryCatch.Exception()).ToLocalChecked();
              }
              else
              {
                error = Undefined();
              }
              if (arg1.IsEmpty()) arg1 = Undefined();
            }
            Local<Value> args[] = {error, arg1};


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

            Local<Value> args[] = {error};
            invokeCallback(_countof(args), args);
          });
        }
      });
    }
    static void LoadAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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

      ::Windows::Foundation::IAsyncActionWithProgress<unsigned __int64>^ op;


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

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

      opTask.then( [asyncToken] (task<void> t) {
        try {
          t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> args[] = {Undefined()};


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

            Local<Value> args[] = {error};
            invokeCallback(_countof(args), args);
          });
        }
      });
    }
    static void SaveAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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

      ::Windows::Foundation::IAsyncOperationWithProgress<unsigned int, unsigned int>^ op;


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

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

      opTask.then( [asyncToken] (task<unsigned int> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = Nan::New<Integer>(result);
              if (tryCatch.HasCaught())
              {
                error = Nan::To<Object>(tryCatch.Exception()).ToLocalChecked();
              }
              else
              {
                error = Undefined();
              }
              if (arg1.IsEmpty()) arg1 = Undefined();
            }
            Local<Value> args[] = {error, arg1};


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

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

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

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

      InkManager *wrapper = InkManager::Unwrap<InkManager>(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->ProcessPointerDown(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 ProcessPointerUpdate(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

      InkManager *wrapper = InkManager::Unwrap<InkManager>(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]));
          
          ::Platform::Object^ result;
          result = wrapper->_instance->ProcessPointerUpdate(arg0);
          info.GetReturnValue().Set(CreateOpaqueWrapper(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void ProcessPointerUp(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

      InkManager *wrapper = InkManager::Unwrap<InkManager>(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]));
          
          ::Windows::Foundation::Rect result;
          result = wrapper->_instance->ProcessPointerUp(arg0);
          info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void SetDefaultDrawingAttributes(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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

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

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

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

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

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

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

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsPoint(info[0]))
      {
        try
        {
          ::Windows::Foundation::Point arg0 = NodeRT::Utils::PointFromJs(info[0]);
          
          ::Windows::Foundation::Rect result;
          result = wrapper->_instance->MoveSelected(arg0);
          info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void SelectWithPolyLine(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Point>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Point>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Point>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Foundation::Point>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsPoint(value);
                 },
                 [](Local<Value> value) -> ::Windows::Foundation::Point {
                   return NodeRT::Utils::PointFromJs(value);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Point>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          ::Windows::Foundation::Rect result;
          result = wrapper->_instance->SelectWithPolyLine(arg0);
          info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void SelectWithLine(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 2
        && NodeRT::Utils::IsPoint(info[0])
        && NodeRT::Utils::IsPoint(info[1]))
      {
        try
        {
          ::Windows::Foundation::Point arg0 = NodeRT::Utils::PointFromJs(info[0]);
          ::Windows::Foundation::Point arg1 = NodeRT::Utils::PointFromJs(info[1]);
          
          ::Windows::Foundation::Rect result;
          result = wrapper->_instance->SelectWithLine(arg0, arg1);
          info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void CopySelectedToClipboard(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsPoint(info[0]))
      {
        try
        {
          ::Windows::Foundation::Point arg0 = NodeRT::Utils::PointFromJs(info[0]);
          
          ::Windows::Foundation::Rect result;
          result = wrapper->_instance->PasteFromClipboard(arg0);
          info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void CanPasteFromClipboard(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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

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

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

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

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::InkStroke^>^ result;
          result = wrapper->_instance->GetStrokes();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::InkStroke^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::InkStroke^ val) -> Local<Value> {
              return WrapInkStroke(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStroke^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::InkStroke^ {
              return UnwrapInkStroke(value);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetRecognitionResults(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::InkRecognitionResult^>^ result;
          result = wrapper->_instance->GetRecognitionResults();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::InkRecognitionResult^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::InkRecognitionResult^ val) -> Local<Value> {
              return WrapInkRecognitionResult(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkRecognitionResult^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::InkRecognitionResult^ {
              return UnwrapInkRecognitionResult(value);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void SetDefaultRecognizer(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::InkRecognizer^>^ result;
          result = wrapper->_instance->GetRecognizers();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::InkRecognizer^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::InkRecognizer^ val) -> Local<Value> {
              return WrapInkRecognizer(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkRecognizer^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::InkRecognizer^ {
              return UnwrapInkRecognizer(value);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



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

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

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

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

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

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

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

      try {

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

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

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

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

      try  {
        ::Windows::Foundation::Rect result = wrapper->_instance->BoundingRect;
        info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


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

      friend v8::Local<v8::Value> WrapInkManager(::Windows::UI::Input::Inking::InkManager^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::InkManager^ UnwrapInkManager(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkManager::s_constructorTemplate;

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

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

  void InitInkManager(Local<Object> exports) {
    InkManager::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("scalingFactor").ToLocalChecked(), ScalingFactorGetter, ScalingFactorSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("predictionTime").ToLocalChecked(), PredictionTimeGetter, PredictionTimeSetter);

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



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

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

    private:

      InkModelerAttributes(::Windows::UI::Input::Inking::InkModelerAttributes^ instance) {
        _instance = instance;
      }

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

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

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

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

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

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

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

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

      ::Windows::UI::Input::Inking::InkModelerAttributes^ winRtInstance;


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

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

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


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

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

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





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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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


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

      friend v8::Local<v8::Value> WrapInkModelerAttributes(::Windows::UI::Input::Inking::InkModelerAttributes^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::InkModelerAttributes^ UnwrapInkModelerAttributes(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkModelerAttributes::s_constructorTemplate;

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

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

  void InitInkModelerAttributes(Local<Object> exports) {
    InkModelerAttributes::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("position").ToLocalChecked(), PositionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pressure").ToLocalChecked(), PressureGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("tiltX").ToLocalChecked(), TiltXGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("tiltY").ToLocalChecked(), TiltYGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("timestamp").ToLocalChecked(), TimestampGetter);

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



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

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

    private:

      InkPoint(::Windows::UI::Input::Inking::InkPoint^ instance) {
        _instance = instance;
      }

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

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

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

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

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

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

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

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

      ::Windows::UI::Input::Inking::InkPoint^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPoint^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::Inking::InkPoint^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 5
        && NodeRT::Utils::IsPoint(info[0])
        && info[1]->IsNumber()
        && info[2]->IsNumber()
        && info[3]->IsNumber()
        && info[4]->IsNumber())
      {
        try {
          ::Windows::Foundation::Point arg0 = NodeRT::Utils::PointFromJs(info[0]);
          float arg1 = static_cast<float>(Nan::To<double>(info[1]).FromMaybe(0.0));
          float arg2 = static_cast<float>(Nan::To<double>(info[2]).FromMaybe(0.0));
          float arg3 = static_cast<float>(Nan::To<double>(info[3]).FromMaybe(0.0));
          unsigned __int64 arg4 = static_cast<unsigned __int64>(Nan::To<int64_t>(info[4]).FromMaybe(0));
          
          winRtInstance = ref new ::Windows::UI::Input::Inking::InkPoint(arg0,arg1,arg2,arg3,arg4);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && NodeRT::Utils::IsPoint(info[0])
        && info[1]->IsNumber())
      {
        try {
          ::Windows::Foundation::Point arg0 = NodeRT::Utils::PointFromJs(info[0]);
          float arg1 = static_cast<float>(Nan::To<double>(info[1]).FromMaybe(0.0));
          
          winRtInstance = ref new ::Windows::UI::Input::Inking::InkPoint(arg0,arg1);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

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

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

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


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

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

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





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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

      friend v8::Local<v8::Value> WrapInkPoint(::Windows::UI::Input::Inking::InkPoint^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::InkPoint^ UnwrapInkPoint(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkPoint::s_constructorTemplate;

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

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

  void InitInkPoint(Local<Object> exports) {
    InkPoint::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "copyDefaultDrawingAttributes", CopyDefaultDrawingAttributes);
            Nan::SetPrototypeMethod(localRef, "updateDefaultDrawingAttributes", UpdateDefaultDrawingAttributes);
            Nan::SetPrototypeMethod(localRef, "activateCustomDrying", ActivateCustomDrying);
            Nan::SetPrototypeMethod(localRef, "setPredefinedConfiguration", SetPredefinedConfiguration);
          


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

          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("strokeContainer").ToLocalChecked(), StrokeContainerGetter, StrokeContainerSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isInputEnabled").ToLocalChecked(), IsInputEnabledGetter, IsInputEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("inputDeviceTypes").ToLocalChecked(), InputDeviceTypesGetter, InputDeviceTypesSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("inputProcessingConfiguration").ToLocalChecked(), InputProcessingConfigurationGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("strokeInput").ToLocalChecked(), StrokeInputGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("unprocessedInput").ToLocalChecked(), UnprocessedInputGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("highContrastAdjustment").ToLocalChecked(), HighContrastAdjustmentGetter, HighContrastAdjustmentSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("inputConfiguration").ToLocalChecked(), InputConfigurationGetter);

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



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

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

    private:

      InkPresenter(::Windows::UI::Input::Inking::InkPresenter^ instance) {
        _instance = instance;
      }

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

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

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

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

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

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

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

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

      ::Windows::UI::Input::Inking::InkPresenter^ winRtInstance;


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

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

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


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

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

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


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

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::UI::Input::Inking::InkDrawingAttributes^ result;
          result = wrapper->_instance->CopyDefaultDrawingAttributes();
          info.GetReturnValue().Set(WrapInkDrawingAttributes(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 UpdateDefaultDrawingAttributes(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::UI::Input::Inking::InkSynchronizer^ result;
          result = wrapper->_instance->ActivateCustomDrying();
          info.GetReturnValue().Set(WrapInkSynchronizer(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 SetPredefinedConfiguration(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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

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

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

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

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

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

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

      try {

        ::Windows::UI::Input::Inking::InkStrokeContainer^ winRtValue = dynamic_cast<::Windows::UI::Input::Inking::InkStrokeContainer^>(NodeRT::Utils::GetObjectInstance(value));

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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


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

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

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

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

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

          registrationToken = wrapper->_instance->StrokesCollected::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Inking::InkPresenter^, ::Windows::UI::Input::Inking::InkStrokesCollectedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Inking::InkPresenter^ arg0, ::Windows::UI::Input::Inking::InkStrokesCollectedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapInkPresenter(arg0);
                  wrappedArg1 = WrapInkStrokesCollectedEventArgs(arg1);


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

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

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

          registrationToken = wrapper->_instance->StrokesErased::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Inking::InkPresenter^, ::Windows::UI::Input::Inking::InkStrokesErasedEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Inking::InkPresenter^ arg0, ::Windows::UI::Input::Inking::InkStrokesErasedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapInkPresenter(arg0);
                  wrappedArg1 = WrapInkStrokesErasedEventArgs(arg1);


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"strokesCollected", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenter^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          InkPresenter *wrapper = InkPresenter::Unwrap<InkPresenter>(info.This());
          wrapper->_instance->StrokesCollected::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"strokesErased", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenter^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          InkPresenter *wrapper = InkPresenter::Unwrap<InkPresenter>(info.This());
          wrapper->_instance->StrokesErased::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

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

      friend v8::Local<v8::Value> WrapInkPresenter(::Windows::UI::Input::Inking::InkPresenter^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::InkPresenter^ UnwrapInkPresenter(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkPresenter::s_constructorTemplate;

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

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

  void InitInkPresenter(Local<Object> exports) {
    InkPresenter::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("radius").ToLocalChecked(), RadiusGetter, RadiusSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isResizable").ToLocalChecked(), IsResizableGetter, IsResizableSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isCenterMarkerVisible").ToLocalChecked(), IsCenterMarkerVisibleGetter, IsCenterMarkerVisibleSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isAngleReadoutVisible").ToLocalChecked(), IsAngleReadoutVisibleGetter, IsAngleReadoutVisibleSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("areTickMarksVisible").ToLocalChecked(), AreTickMarksVisibleGetter, AreTickMarksVisibleSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("areRaysVisible").ToLocalChecked(), AreRaysVisibleGetter, AreRaysVisibleSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("accentColor").ToLocalChecked(), AccentColorGetter, AccentColorSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("transform").ToLocalChecked(), TransformGetter, TransformSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isVisible").ToLocalChecked(), IsVisibleGetter, IsVisibleSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("foregroundColor").ToLocalChecked(), ForegroundColorGetter, ForegroundColorSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("backgroundColor").ToLocalChecked(), BackgroundColorGetter, BackgroundColorSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);

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



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

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

    private:

      InkPresenterProtractor(::Windows::UI::Input::Inking::InkPresenterProtractor^ instance) {
        _instance = instance;
      }

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

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

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

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

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

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

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

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

      ::Windows::UI::Input::Inking::InkPresenterProtractor^ winRtInstance;


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

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

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

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


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

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

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





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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

      try  {
        ::Windows::UI::Color result = wrapper->_instance->AccentColor;
        info.GetReturnValue().Set(NodeRT::Utils::ColorToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AccentColorSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterProtractor^>(info.This())) {
        return;
      }

      InkPresenterProtractor *wrapper = InkPresenterProtractor::Unwrap<InkPresenterProtractor>(info.This());

      try {

        ::Windows::UI::Color winRtValue = NodeRT::Utils::ColorFromJs(value);

        wrapper->_instance->AccentColor = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void TransformGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterProtractor^>(info.This())) {
        return;
      }

      InkPresenterProtractor *wrapper = InkPresenterProtractor::Unwrap<InkPresenterProtractor>(info.This());

      try  {
        ::Windows::Foundation::Numerics::float3x2 result = wrapper->_instance->Transform;
        info.GetReturnValue().Set(Matrix3x2ToJsObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TransformSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!IsMatrix3x2JsObject(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterProtractor^>(info.This())) {
        return;
      }

      InkPresenterProtractor *wrapper = InkPresenterProtractor::Unwrap<InkPresenterProtractor>(info.This());

      try {

        ::Windows::Foundation::Numerics::float3x2 winRtValue = Matrix3x2FromJsObject(value);

        wrapper->_instance->Transform = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsVisibleGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterProtractor^>(info.This())) {
        return;
      }

      InkPresenterProtractor *wrapper = InkPresenterProtractor::Unwrap<InkPresenterProtractor>(info.This());

      try  {
        bool result = wrapper->_instance->IsVisible;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsVisibleSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterProtractor^>(info.This())) {
        return;
      }

      InkPresenterProtractor *wrapper = InkPresenterProtractor::Unwrap<InkPresenterProtractor>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsVisible = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ForegroundColorGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterProtractor^>(info.This())) {
        return;
      }

      InkPresenterProtractor *wrapper = InkPresenterProtractor::Unwrap<InkPresenterProtractor>(info.This());

      try  {
        ::Windows::UI::Color result = wrapper->_instance->ForegroundColor;
        info.GetReturnValue().Set(NodeRT::Utils::ColorToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ForegroundColorSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterProtractor^>(info.This())) {
        return;
      }

      InkPresenterProtractor *wrapper = InkPresenterProtractor::Unwrap<InkPresenterProtractor>(info.This());

      try {

        ::Windows::UI::Color winRtValue = NodeRT::Utils::ColorFromJs(value);

        wrapper->_instance->ForegroundColor = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void BackgroundColorGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterProtractor^>(info.This())) {
        return;
      }

      InkPresenterProtractor *wrapper = InkPresenterProtractor::Unwrap<InkPresenterProtractor>(info.This());

      try  {
        ::Windows::UI::Color result = wrapper->_instance->BackgroundColor;
        info.GetReturnValue().Set(NodeRT::Utils::ColorToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BackgroundColorSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterProtractor^>(info.This())) {
        return;
      }

      InkPresenterProtractor *wrapper = InkPresenterProtractor::Unwrap<InkPresenterProtractor>(info.This());

      try {

        ::Windows::UI::Color winRtValue = NodeRT::Utils::ColorFromJs(value);

        wrapper->_instance->BackgroundColor = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void KindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterProtractor^>(info.This())) {
        return;
      }

      InkPresenterProtractor *wrapper = InkPresenterProtractor::Unwrap<InkPresenterProtractor>(info.This());

      try  {
        ::Windows::UI::Input::Inking::InkPresenterStencilKind result = wrapper->_instance->Kind;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::Inking::InkPresenterProtractor^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInkPresenterProtractor(::Windows::UI::Input::Inking::InkPresenterProtractor^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::InkPresenterProtractor^ UnwrapInkPresenterProtractor(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkPresenterProtractor::s_constructorTemplate;

  v8::Local<v8::Value> WrapInkPresenterProtractor(::Windows::UI::Input::Inking::InkPresenterProtractor^ 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>(InkPresenterProtractor::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::Inking::InkPresenterProtractor^ UnwrapInkPresenterProtractor(Local<Value> value) {
     return InkPresenterProtractor::Unwrap<InkPresenterProtractor>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInkPresenterProtractor(Local<Object> exports) {
    InkPresenterProtractor::Init(exports);
  }

  class InkPresenterRuler : 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>("InkPresenterRuler").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("width").ToLocalChecked(), WidthGetter, WidthSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("length").ToLocalChecked(), LengthGetter, LengthSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isCompassVisible").ToLocalChecked(), IsCompassVisibleGetter, IsCompassVisibleSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("areTickMarksVisible").ToLocalChecked(), AreTickMarksVisibleGetter, AreTickMarksVisibleSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("transform").ToLocalChecked(), TransformGetter, TransformSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isVisible").ToLocalChecked(), IsVisibleGetter, IsVisibleSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("foregroundColor").ToLocalChecked(), ForegroundColorGetter, ForegroundColorSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("backgroundColor").ToLocalChecked(), BackgroundColorGetter, BackgroundColorSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("InkPresenterRuler").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      InkPresenterRuler(::Windows::UI::Input::Inking::InkPresenterRuler^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Input::Inking::InkPresenterRuler^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterRuler^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::Inking::InkPresenterRuler^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenter^>(info[0]))
      {
        try {
          ::Windows::UI::Input::Inking::InkPresenter^ arg0 = UnwrapInkPresenter(info[0]);
          
          winRtInstance = ref new ::Windows::UI::Input::Inking::InkPresenterRuler(arg0);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      InkPresenterRuler *wrapperInstance = new InkPresenterRuler(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterRuler^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Input::Inking::InkPresenterRuler^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::Inking::InkPresenterRuler^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapInkPresenterRuler(winRtInstance));
    }





    static void WidthGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterRuler^>(info.This())) {
        return;
      }

      InkPresenterRuler *wrapper = InkPresenterRuler::Unwrap<InkPresenterRuler>(info.This());

      try  {
        double result = wrapper->_instance->Width;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void WidthSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterRuler^>(info.This())) {
        return;
      }

      InkPresenterRuler *wrapper = InkPresenterRuler::Unwrap<InkPresenterRuler>(info.This());

      try {

        double winRtValue = Nan::To<double>(value).FromMaybe(0.0);

        wrapper->_instance->Width = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void LengthGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterRuler^>(info.This())) {
        return;
      }

      InkPresenterRuler *wrapper = InkPresenterRuler::Unwrap<InkPresenterRuler>(info.This());

      try  {
        double result = wrapper->_instance->Length;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void LengthSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterRuler^>(info.This())) {
        return;
      }

      InkPresenterRuler *wrapper = InkPresenterRuler::Unwrap<InkPresenterRuler>(info.This());

      try {

        double winRtValue = Nan::To<double>(value).FromMaybe(0.0);

        wrapper->_instance->Length = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsCompassVisibleGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterRuler^>(info.This())) {
        return;
      }

      InkPresenterRuler *wrapper = InkPresenterRuler::Unwrap<InkPresenterRuler>(info.This());

      try  {
        bool result = wrapper->_instance->IsCompassVisible;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsCompassVisibleSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterRuler^>(info.This())) {
        return;
      }

      InkPresenterRuler *wrapper = InkPresenterRuler::Unwrap<InkPresenterRuler>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsCompassVisible = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void AreTickMarksVisibleGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterRuler^>(info.This())) {
        return;
      }

      InkPresenterRuler *wrapper = InkPresenterRuler::Unwrap<InkPresenterRuler>(info.This());

      try  {
        bool result = wrapper->_instance->AreTickMarksVisible;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AreTickMarksVisibleSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterRuler^>(info.This())) {
        return;
      }

      InkPresenterRuler *wrapper = InkPresenterRuler::Unwrap<InkPresenterRuler>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->AreTickMarksVisible = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void TransformGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterRuler^>(info.This())) {
        return;
      }

      InkPresenterRuler *wrapper = InkPresenterRuler::Unwrap<InkPresenterRuler>(info.This());

      try  {
        ::Windows::Foundation::Numerics::float3x2 result = wrapper->_instance->Transform;
        info.GetReturnValue().Set(Matrix3x2ToJsObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TransformSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!IsMatrix3x2JsObject(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterRuler^>(info.This())) {
        return;
      }

      InkPresenterRuler *wrapper = InkPresenterRuler::Unwrap<InkPresenterRuler>(info.This());

      try {

        ::Windows::Foundation::Numerics::float3x2 winRtValue = Matrix3x2FromJsObject(value);

        wrapper->_instance->Transform = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsVisibleGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterRuler^>(info.This())) {
        return;
      }

      InkPresenterRuler *wrapper = InkPresenterRuler::Unwrap<InkPresenterRuler>(info.This());

      try  {
        bool result = wrapper->_instance->IsVisible;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsVisibleSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterRuler^>(info.This())) {
        return;
      }

      InkPresenterRuler *wrapper = InkPresenterRuler::Unwrap<InkPresenterRuler>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsVisible = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ForegroundColorGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterRuler^>(info.This())) {
        return;
      }

      InkPresenterRuler *wrapper = InkPresenterRuler::Unwrap<InkPresenterRuler>(info.This());

      try  {
        ::Windows::UI::Color result = wrapper->_instance->ForegroundColor;
        info.GetReturnValue().Set(NodeRT::Utils::ColorToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ForegroundColorSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterRuler^>(info.This())) {
        return;
      }

      InkPresenterRuler *wrapper = InkPresenterRuler::Unwrap<InkPresenterRuler>(info.This());

      try {

        ::Windows::UI::Color winRtValue = NodeRT::Utils::ColorFromJs(value);

        wrapper->_instance->ForegroundColor = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void BackgroundColorGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterRuler^>(info.This())) {
        return;
      }

      InkPresenterRuler *wrapper = InkPresenterRuler::Unwrap<InkPresenterRuler>(info.This());

      try  {
        ::Windows::UI::Color result = wrapper->_instance->BackgroundColor;
        info.GetReturnValue().Set(NodeRT::Utils::ColorToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BackgroundColorSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsColor(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterRuler^>(info.This())) {
        return;
      }

      InkPresenterRuler *wrapper = InkPresenterRuler::Unwrap<InkPresenterRuler>(info.This());

      try {

        ::Windows::UI::Color winRtValue = NodeRT::Utils::ColorFromJs(value);

        wrapper->_instance->BackgroundColor = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void KindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPresenterRuler^>(info.This())) {
        return;
      }

      InkPresenterRuler *wrapper = InkPresenterRuler::Unwrap<InkPresenterRuler>(info.This());

      try  {
        ::Windows::UI::Input::Inking::InkPresenterStencilKind result = wrapper->_instance->Kind;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::Inking::InkPresenterRuler^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInkPresenterRuler(::Windows::UI::Input::Inking::InkPresenterRuler^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::InkPresenterRuler^ UnwrapInkPresenterRuler(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkPresenterRuler::s_constructorTemplate;

  v8::Local<v8::Value> WrapInkPresenterRuler(::Windows::UI::Input::Inking::InkPresenterRuler^ 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>(InkPresenterRuler::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::Inking::InkPresenterRuler^ UnwrapInkPresenterRuler(Local<Value> value) {
     return InkPresenterRuler::Unwrap<InkPresenterRuler>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInkPresenterRuler(Local<Object> exports) {
    InkPresenterRuler::Init(exports);
  }

  class InkRecognitionResult : 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>("InkRecognitionResult").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "getTextCandidates", GetTextCandidates);
            Nan::SetPrototypeMethod(localRef, "getStrokes", GetStrokes);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("boundingRect").ToLocalChecked(), BoundingRectGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("InkRecognitionResult").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      InkRecognitionResult(::Windows::UI::Input::Inking::InkRecognitionResult^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Input::Inking::InkRecognitionResult^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkRecognitionResult^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::Inking::InkRecognitionResult^) 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());

      InkRecognitionResult *wrapperInstance = new InkRecognitionResult(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkRecognitionResult^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Input::Inking::InkRecognitionResult^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::Inking::InkRecognitionResult^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapInkRecognitionResult(winRtInstance));
    }


    static void GetTextCandidates(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkRecognitionResult^>(info.This())) {
        return;
      }

      InkRecognitionResult *wrapper = InkRecognitionResult::Unwrap<InkRecognitionResult>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Platform::String^>^ result;
          result = wrapper->_instance->GetTextCandidates();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Platform::String^>::CreateVectorViewWrapper(result, 
            [](::Platform::String^ val) -> Local<Value> {
              return NodeRT::Utils::NewString(val->Data());
            },
            [](Local<Value> value) -> bool {
              return value->IsString();
            },
            [](Local<Value> value) -> ::Platform::String^ {
              return ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetStrokes(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkRecognitionResult^>(info.This())) {
        return;
      }

      InkRecognitionResult *wrapper = InkRecognitionResult::Unwrap<InkRecognitionResult>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::InkStroke^>^ result;
          result = wrapper->_instance->GetStrokes();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::InkStroke^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::InkStroke^ val) -> Local<Value> {
              return WrapInkStroke(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStroke^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::InkStroke^ {
              return UnwrapInkStroke(value);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    static void BoundingRectGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkRecognitionResult^>(info.This())) {
        return;
      }

      InkRecognitionResult *wrapper = InkRecognitionResult::Unwrap<InkRecognitionResult>(info.This());

      try  {
        ::Windows::Foundation::Rect result = wrapper->_instance->BoundingRect;
        info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::Inking::InkRecognitionResult^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInkRecognitionResult(::Windows::UI::Input::Inking::InkRecognitionResult^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::InkRecognitionResult^ UnwrapInkRecognitionResult(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkRecognitionResult::s_constructorTemplate;

  v8::Local<v8::Value> WrapInkRecognitionResult(::Windows::UI::Input::Inking::InkRecognitionResult^ 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>(InkRecognitionResult::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::Inking::InkRecognitionResult^ UnwrapInkRecognitionResult(Local<Value> value) {
     return InkRecognitionResult::Unwrap<InkRecognitionResult>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInkRecognitionResult(Local<Object> exports) {
    InkRecognitionResult::Init(exports);
  }

  class InkRecognizer : 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>("InkRecognizer").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("name").ToLocalChecked(), NameGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("InkRecognizer").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      InkRecognizer(::Windows::UI::Input::Inking::InkRecognizer^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Input::Inking::InkRecognizer^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkRecognizer^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::Inking::InkRecognizer^) 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());

      InkRecognizer *wrapperInstance = new InkRecognizer(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkRecognizer^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Input::Inking::InkRecognizer^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::Inking::InkRecognizer^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapInkRecognizer(winRtInstance));
    }





    static void NameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkRecognizer^>(info.This())) {
        return;
      }

      InkRecognizer *wrapper = InkRecognizer::Unwrap<InkRecognizer>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Name;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::Inking::InkRecognizer^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInkRecognizer(::Windows::UI::Input::Inking::InkRecognizer^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::InkRecognizer^ UnwrapInkRecognizer(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkRecognizer::s_constructorTemplate;

  v8::Local<v8::Value> WrapInkRecognizer(::Windows::UI::Input::Inking::InkRecognizer^ 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>(InkRecognizer::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::Inking::InkRecognizer^ UnwrapInkRecognizer(Local<Value> value) {
     return InkRecognizer::Unwrap<InkRecognizer>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInkRecognizer(Local<Object> exports) {
    InkRecognizer::Init(exports);
  }

  class InkRecognizerContainer : 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>("InkRecognizerContainer").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);

        Local<Function> func;
        Local<FunctionTemplate> funcTemplate;

          
            Nan::SetPrototypeMethod(localRef, "setDefaultRecognizer", SetDefaultRecognizer);
            Nan::SetPrototypeMethod(localRef, "getRecognizers", GetRecognizers);
          

          
            Nan::SetPrototypeMethod(localRef, "recognizeAsync", RecognizeAsync);
          



        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("InkRecognizerContainer").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      InkRecognizerContainer(::Windows::UI::Input::Inking::InkRecognizerContainer^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Input::Inking::InkRecognizerContainer^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkRecognizerContainer^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::Inking::InkRecognizerContainer^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Input::Inking::InkRecognizerContainer();
        } 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());

      InkRecognizerContainer *wrapperInstance = new InkRecognizerContainer(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkRecognizerContainer^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Input::Inking::InkRecognizerContainer^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::Inking::InkRecognizerContainer^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapInkRecognizerContainer(winRtInstance));
    }

    static void RecognizeAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkRecognizerContainer^>(info.This())) {
        return;
      }

      if (info.Length() == 0 || !info[info.Length() -1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: No callback was given")));
        return;
      }

      InkRecognizerContainer *wrapper = InkRecognizerContainer::Unwrap<InkRecognizerContainer>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::InkRecognitionResult^>^>^ op;


      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeContainer^>(info[0])
        && info[1]->IsInt32())
      {
        try
        {
          ::Windows::UI::Input::Inking::InkStrokeContainer^ arg0 = UnwrapInkStrokeContainer(info[0]);
          ::Windows::UI::Input::Inking::InkRecognitionTarget arg1 = static_cast<::Windows::UI::Input::Inking::InkRecognitionTarget>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          op = wrapper->_instance->RecognizeAsync(arg0,arg1);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

      auto opTask = create_task(op);
      uv_async_t* asyncToken = NodeUtils::Async::GetAsyncToken(info[info.Length() -1].As<Function>());

      opTask.then( [asyncToken] (task<::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::InkRecognitionResult^>^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::InkRecognitionResult^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::InkRecognitionResult^ val) -> Local<Value> {
              return WrapInkRecognitionResult(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkRecognitionResult^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::InkRecognitionResult^ {
              return UnwrapInkRecognitionResult(value);
            }
          );
              if (tryCatch.HasCaught())
              {
                error = Nan::To<Object>(tryCatch.Exception()).ToLocalChecked();
              }
              else
              {
                error = Undefined();
              }
              if (arg1.IsEmpty()) arg1 = Undefined();
            }
            Local<Value> args[] = {error, arg1};


            invokeCallback(_countof(args), args);
          });
        } catch (Platform::Exception^ exception) {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {
            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

            Local<Value> args[] = {error};
            invokeCallback(_countof(args), args);
          });
        }
      });
    }

    static void SetDefaultRecognizer(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkRecognizerContainer^>(info.This())) {
        return;
      }

      InkRecognizerContainer *wrapper = InkRecognizerContainer::Unwrap<InkRecognizerContainer>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkRecognizer^>(info[0]))
      {
        try
        {
          ::Windows::UI::Input::Inking::InkRecognizer^ arg0 = UnwrapInkRecognizer(info[0]);
          
          wrapper->_instance->SetDefaultRecognizer(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 GetRecognizers(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkRecognizerContainer^>(info.This())) {
        return;
      }

      InkRecognizerContainer *wrapper = InkRecognizerContainer::Unwrap<InkRecognizerContainer>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::InkRecognizer^>^ result;
          result = wrapper->_instance->GetRecognizers();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::InkRecognizer^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::InkRecognizer^ val) -> Local<Value> {
              return WrapInkRecognizer(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkRecognizer^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::InkRecognizer^ {
              return UnwrapInkRecognizer(value);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





    private:
      ::Windows::UI::Input::Inking::InkRecognizerContainer^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInkRecognizerContainer(::Windows::UI::Input::Inking::InkRecognizerContainer^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::InkRecognizerContainer^ UnwrapInkRecognizerContainer(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkRecognizerContainer::s_constructorTemplate;

  v8::Local<v8::Value> WrapInkRecognizerContainer(::Windows::UI::Input::Inking::InkRecognizerContainer^ 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>(InkRecognizerContainer::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::Inking::InkRecognizerContainer^ UnwrapInkRecognizerContainer(Local<Value> value) {
     return InkRecognizerContainer::Unwrap<InkRecognizerContainer>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInkRecognizerContainer(Local<Object> exports) {
    InkRecognizerContainer::Init(exports);
  }

  class InkStroke : 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>("InkStroke").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "getRenderingSegments", GetRenderingSegments);
            Nan::SetPrototypeMethod(localRef, "clone", Clone);
            Nan::SetPrototypeMethod(localRef, "getInkPoints", GetInkPoints);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("selected").ToLocalChecked(), SelectedGetter, SelectedSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("drawingAttributes").ToLocalChecked(), DrawingAttributesGetter, DrawingAttributesSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("boundingRect").ToLocalChecked(), BoundingRectGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("recognized").ToLocalChecked(), RecognizedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pointTransform").ToLocalChecked(), PointTransformGetter, PointTransformSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("strokeStartedTime").ToLocalChecked(), StrokeStartedTimeGetter, StrokeStartedTimeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("strokeDuration").ToLocalChecked(), StrokeDurationGetter, StrokeDurationSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("id").ToLocalChecked(), IdGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("InkStroke").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      InkStroke(::Windows::UI::Input::Inking::InkStroke^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Input::Inking::InkStroke^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStroke^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::Inking::InkStroke^) 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());

      InkStroke *wrapperInstance = new InkStroke(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStroke^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Input::Inking::InkStroke^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::Inking::InkStroke^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapInkStroke(winRtInstance));
    }


    static void GetRenderingSegments(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStroke^>(info.This())) {
        return;
      }

      InkStroke *wrapper = InkStroke::Unwrap<InkStroke>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::InkStrokeRenderingSegment^>^ result;
          result = wrapper->_instance->GetRenderingSegments();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::InkStrokeRenderingSegment^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::InkStrokeRenderingSegment^ val) -> Local<Value> {
              return WrapInkStrokeRenderingSegment(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeRenderingSegment^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::InkStrokeRenderingSegment^ {
              return UnwrapInkStrokeRenderingSegment(value);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Clone(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStroke^>(info.This())) {
        return;
      }

      InkStroke *wrapper = InkStroke::Unwrap<InkStroke>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::UI::Input::Inking::InkStroke^ result;
          result = wrapper->_instance->Clone();
          info.GetReturnValue().Set(WrapInkStroke(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 GetInkPoints(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStroke^>(info.This())) {
        return;
      }

      InkStroke *wrapper = InkStroke::Unwrap<InkStroke>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::InkPoint^>^ result;
          result = wrapper->_instance->GetInkPoints();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::InkPoint^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::InkPoint^ val) -> Local<Value> {
              return WrapInkPoint(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPoint^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::InkPoint^ {
              return UnwrapInkPoint(value);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    static void SelectedGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStroke^>(info.This())) {
        return;
      }

      InkStroke *wrapper = InkStroke::Unwrap<InkStroke>(info.This());

      try  {
        bool result = wrapper->_instance->Selected;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SelectedSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsBoolean()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStroke^>(info.This())) {
        return;
      }

      InkStroke *wrapper = InkStroke::Unwrap<InkStroke>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->Selected = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void DrawingAttributesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStroke^>(info.This())) {
        return;
      }

      InkStroke *wrapper = InkStroke::Unwrap<InkStroke>(info.This());

      try  {
        ::Windows::UI::Input::Inking::InkDrawingAttributes^ result = wrapper->_instance->DrawingAttributes;
        info.GetReturnValue().Set(WrapInkDrawingAttributes(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DrawingAttributesSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkDrawingAttributes^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStroke^>(info.This())) {
        return;
      }

      InkStroke *wrapper = InkStroke::Unwrap<InkStroke>(info.This());

      try {

        ::Windows::UI::Input::Inking::InkDrawingAttributes^ winRtValue = dynamic_cast<::Windows::UI::Input::Inking::InkDrawingAttributes^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->DrawingAttributes = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void BoundingRectGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStroke^>(info.This())) {
        return;
      }

      InkStroke *wrapper = InkStroke::Unwrap<InkStroke>(info.This());

      try  {
        ::Windows::Foundation::Rect result = wrapper->_instance->BoundingRect;
        info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RecognizedGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStroke^>(info.This())) {
        return;
      }

      InkStroke *wrapper = InkStroke::Unwrap<InkStroke>(info.This());

      try  {
        bool result = wrapper->_instance->Recognized;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PointTransformGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStroke^>(info.This())) {
        return;
      }

      InkStroke *wrapper = InkStroke::Unwrap<InkStroke>(info.This());

      try  {
        ::Windows::Foundation::Numerics::float3x2 result = wrapper->_instance->PointTransform;
        info.GetReturnValue().Set(Matrix3x2ToJsObject(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PointTransformSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!IsMatrix3x2JsObject(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStroke^>(info.This())) {
        return;
      }

      InkStroke *wrapper = InkStroke::Unwrap<InkStroke>(info.This());

      try {

        ::Windows::Foundation::Numerics::float3x2 winRtValue = Matrix3x2FromJsObject(value);

        wrapper->_instance->PointTransform = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void StrokeStartedTimeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStroke^>(info.This())) {
        return;
      }

      InkStroke *wrapper = InkStroke::Unwrap<InkStroke>(info.This());

      try  {
        ::Platform::IBox<::Windows::Foundation::DateTime>^ result = wrapper->_instance->StrokeStartedTime;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::DateTimeToJS(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void StrokeStartedTimeSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsDate()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStroke^>(info.This())) {
        return;
      }

      InkStroke *wrapper = InkStroke::Unwrap<InkStroke>(info.This());

      try {

        ::Platform::IBox<::Windows::Foundation::DateTime>^ winRtValue = ref new ::Platform::Box<::Windows::Foundation::DateTime>(NodeRT::Utils::DateTimeFromJSDate(value));

        wrapper->_instance->StrokeStartedTime = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void StrokeDurationGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStroke^>(info.This())) {
        return;
      }

      InkStroke *wrapper = InkStroke::Unwrap<InkStroke>(info.This());

      try  {
        ::Platform::IBox<::Windows::Foundation::TimeSpan>^ result = wrapper->_instance->StrokeDuration;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Number>(result->Value.Duration/10000.0)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void StrokeDurationSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStroke^>(info.This())) {
        return;
      }

      InkStroke *wrapper = InkStroke::Unwrap<InkStroke>(info.This());

      try {

        ::Platform::IBox<::Windows::Foundation::TimeSpan>^ winRtValue = ref new ::Platform::Box<::Windows::Foundation::TimeSpan>(NodeRT::Utils::TimeSpanFromMilli(Nan::To<int64_t>(value).FromMaybe(0)));

        wrapper->_instance->StrokeDuration = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStroke^>(info.This())) {
        return;
      }

      InkStroke *wrapper = InkStroke::Unwrap<InkStroke>(info.This());

      try  {
        unsigned int result = wrapper->_instance->Id;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::Inking::InkStroke^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInkStroke(::Windows::UI::Input::Inking::InkStroke^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::InkStroke^ UnwrapInkStroke(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkStroke::s_constructorTemplate;

  v8::Local<v8::Value> WrapInkStroke(::Windows::UI::Input::Inking::InkStroke^ 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>(InkStroke::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::Inking::InkStroke^ UnwrapInkStroke(Local<Value> value) {
     return InkStroke::Unwrap<InkStroke>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInkStroke(Local<Object> exports) {
    InkStroke::Init(exports);
  }

  class InkStrokeBuilder : 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>("InkStrokeBuilder").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "beginStroke", BeginStroke);
            Nan::SetPrototypeMethod(localRef, "appendToStroke", AppendToStroke);
            Nan::SetPrototypeMethod(localRef, "endStroke", EndStroke);
            Nan::SetPrototypeMethod(localRef, "createStroke", CreateStroke);
            Nan::SetPrototypeMethod(localRef, "setDefaultDrawingAttributes", SetDefaultDrawingAttributes);
            Nan::SetPrototypeMethod(localRef, "createStrokeFromInkPoints", CreateStrokeFromInkPoints);
          




        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("InkStrokeBuilder").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      InkStrokeBuilder(::Windows::UI::Input::Inking::InkStrokeBuilder^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Input::Inking::InkStrokeBuilder^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeBuilder^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::Inking::InkStrokeBuilder^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Input::Inking::InkStrokeBuilder();
        } 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());

      InkStrokeBuilder *wrapperInstance = new InkStrokeBuilder(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeBuilder^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Input::Inking::InkStrokeBuilder^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::Inking::InkStrokeBuilder^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapInkStrokeBuilder(winRtInstance));
    }


    static void BeginStroke(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeBuilder^>(info.This())) {
        return;
      }

      InkStrokeBuilder *wrapper = InkStrokeBuilder::Unwrap<InkStrokeBuilder>(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->BeginStroke(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 AppendToStroke(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeBuilder^>(info.This())) {
        return;
      }

      InkStrokeBuilder *wrapper = InkStrokeBuilder::Unwrap<InkStrokeBuilder>(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]));
          
          ::Windows::UI::Input::PointerPoint^ result;
          result = wrapper->_instance->AppendToStroke(arg0);
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Input", "PointerPoint", 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 EndStroke(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeBuilder^>(info.This())) {
        return;
      }

      InkStrokeBuilder *wrapper = InkStrokeBuilder::Unwrap<InkStrokeBuilder>(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]));
          
          ::Windows::UI::Input::Inking::InkStroke^ result;
          result = wrapper->_instance->EndStroke(arg0);
          info.GetReturnValue().Set(WrapInkStroke(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 CreateStroke(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeBuilder^>(info.This())) {
        return;
      }

      InkStrokeBuilder *wrapper = InkStrokeBuilder::Unwrap<InkStrokeBuilder>(info.This());

      if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Point>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Point>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Point>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Foundation::Point>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsPoint(value);
                 },
                 [](Local<Value> value) -> ::Windows::Foundation::Point {
                   return NodeRT::Utils::PointFromJs(value);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Point>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          ::Windows::UI::Input::Inking::InkStroke^ result;
          result = wrapper->_instance->CreateStroke(arg0);
          info.GetReturnValue().Set(WrapInkStroke(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 SetDefaultDrawingAttributes(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeBuilder^>(info.This())) {
        return;
      }

      InkStrokeBuilder *wrapper = InkStrokeBuilder::Unwrap<InkStrokeBuilder>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkDrawingAttributes^>(info[0]))
      {
        try
        {
          ::Windows::UI::Input::Inking::InkDrawingAttributes^ arg0 = UnwrapInkDrawingAttributes(info[0]);
          
          wrapper->_instance->SetDefaultDrawingAttributes(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 CreateStrokeFromInkPoints(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeBuilder^>(info.This())) {
        return;
      }

      InkStrokeBuilder *wrapper = InkStrokeBuilder::Unwrap<InkStrokeBuilder>(info.This());

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Windows::UI::Input::Inking::InkPoint^>^>(info[0]) || info[0]->IsArray())
        && IsMatrix3x2JsObject(info[1]))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<::Windows::UI::Input::Inking::InkPoint^>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Windows::UI::Input::Inking::InkPoint^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::UI::Input::Inking::InkPoint^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPoint^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::UI::Input::Inking::InkPoint^ {
                   return UnwrapInkPoint(value);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Windows::UI::Input::Inking::InkPoint^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Foundation::Numerics::float3x2 arg1 = Matrix3x2FromJsObject(info[1]);
          
          ::Windows::UI::Input::Inking::InkStroke^ result;
          result = wrapper->_instance->CreateStrokeFromInkPoints(arg0, arg1);
          info.GetReturnValue().Set(WrapInkStroke(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 4
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Windows::UI::Input::Inking::InkPoint^>^>(info[0]) || info[0]->IsArray())
        && IsMatrix3x2JsObject(info[1])
        && info[2]->IsDate()
        && info[3]->IsNumber())
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<::Windows::UI::Input::Inking::InkPoint^>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Windows::UI::Input::Inking::InkPoint^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::UI::Input::Inking::InkPoint^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkPoint^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::UI::Input::Inking::InkPoint^ {
                   return UnwrapInkPoint(value);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Windows::UI::Input::Inking::InkPoint^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Foundation::Numerics::float3x2 arg1 = Matrix3x2FromJsObject(info[1]);
          ::Platform::IBox<::Windows::Foundation::DateTime>^ arg2 = ref new ::Platform::Box<::Windows::Foundation::DateTime>(NodeRT::Utils::DateTimeFromJSDate(info[2]));
          ::Platform::IBox<::Windows::Foundation::TimeSpan>^ arg3 = ref new ::Platform::Box<::Windows::Foundation::TimeSpan>(NodeRT::Utils::TimeSpanFromMilli(Nan::To<int64_t>(info[3]).FromMaybe(0)));
          
          ::Windows::UI::Input::Inking::InkStroke^ result;
          result = wrapper->_instance->CreateStrokeFromInkPoints(arg0, arg1, arg2, arg3);
          info.GetReturnValue().Set(WrapInkStroke(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





    private:
      ::Windows::UI::Input::Inking::InkStrokeBuilder^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInkStrokeBuilder(::Windows::UI::Input::Inking::InkStrokeBuilder^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::InkStrokeBuilder^ UnwrapInkStrokeBuilder(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkStrokeBuilder::s_constructorTemplate;

  v8::Local<v8::Value> WrapInkStrokeBuilder(::Windows::UI::Input::Inking::InkStrokeBuilder^ 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>(InkStrokeBuilder::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::Inking::InkStrokeBuilder^ UnwrapInkStrokeBuilder(Local<Value> value) {
     return InkStrokeBuilder::Unwrap<InkStrokeBuilder>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInkStrokeBuilder(Local<Object> exports) {
    InkStrokeBuilder::Init(exports);
  }

  class InkStrokeContainer : 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>("InkStrokeContainer").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);

        Local<Function> func;
        Local<FunctionTemplate> funcTemplate;

          
            Nan::SetPrototypeMethod(localRef, "addStroke", AddStroke);
            Nan::SetPrototypeMethod(localRef, "deleteSelected", DeleteSelected);
            Nan::SetPrototypeMethod(localRef, "moveSelected", MoveSelected);
            Nan::SetPrototypeMethod(localRef, "selectWithPolyLine", SelectWithPolyLine);
            Nan::SetPrototypeMethod(localRef, "selectWithLine", SelectWithLine);
            Nan::SetPrototypeMethod(localRef, "copySelectedToClipboard", CopySelectedToClipboard);
            Nan::SetPrototypeMethod(localRef, "pasteFromClipboard", PasteFromClipboard);
            Nan::SetPrototypeMethod(localRef, "canPasteFromClipboard", CanPasteFromClipboard);
            Nan::SetPrototypeMethod(localRef, "updateRecognitionResults", UpdateRecognitionResults);
            Nan::SetPrototypeMethod(localRef, "getStrokes", GetStrokes);
            Nan::SetPrototypeMethod(localRef, "getRecognitionResults", GetRecognitionResults);
            Nan::SetPrototypeMethod(localRef, "addStrokes", AddStrokes);
            Nan::SetPrototypeMethod(localRef, "clear", Clear);
            Nan::SetPrototypeMethod(localRef, "getStrokeById", GetStrokeById);
          

          
            Nan::SetPrototypeMethod(localRef, "loadAsync", LoadAsync);
            Nan::SetPrototypeMethod(localRef, "saveAsync", SaveAsync);
          


          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("boundingRect").ToLocalChecked(), BoundingRectGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("InkStrokeContainer").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      InkStrokeContainer(::Windows::UI::Input::Inking::InkStrokeContainer^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Input::Inking::InkStrokeContainer^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeContainer^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::Inking::InkStrokeContainer^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::UI::Input::Inking::InkStrokeContainer();
        } 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());

      InkStrokeContainer *wrapperInstance = new InkStrokeContainer(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeContainer^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Input::Inking::InkStrokeContainer^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::Inking::InkStrokeContainer^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapInkStrokeContainer(winRtInstance));
    }

    static void LoadAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeContainer^>(info.This())) {
        return;
      }

      if (info.Length() == 0 || !info[info.Length() -1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: No callback was given")));
        return;
      }

      InkStrokeContainer *wrapper = InkStrokeContainer::Unwrap<InkStrokeContainer>(info.This());

      ::Windows::Foundation::IAsyncActionWithProgress<unsigned __int64>^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IInputStream^>(info[0]))
      {
        try
        {
          ::Windows::Storage::Streams::IInputStream^ arg0 = dynamic_cast<::Windows::Storage::Streams::IInputStream^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          op = wrapper->_instance->LoadAsync(arg0);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

      auto opTask = create_task(op);
      uv_async_t* asyncToken = NodeUtils::Async::GetAsyncToken(info[info.Length() -1].As<Function>());

      opTask.then( [asyncToken] (task<void> t) {
        try {
          t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> args[] = {Undefined()};


            invokeCallback(_countof(args), args);
          });
        } catch (Platform::Exception^ exception) {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {
            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

            Local<Value> args[] = {error};
            invokeCallback(_countof(args), args);
          });
        }
      });
    }
    static void SaveAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeContainer^>(info.This())) {
        return;
      }

      if (info.Length() == 0 || !info[info.Length() -1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: No callback was given")));
        return;
      }

      InkStrokeContainer *wrapper = InkStrokeContainer::Unwrap<InkStrokeContainer>(info.This());

      ::Windows::Foundation::IAsyncOperationWithProgress<unsigned int, unsigned int>^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IOutputStream^>(info[0]))
      {
        try
        {
          ::Windows::Storage::Streams::IOutputStream^ arg0 = dynamic_cast<::Windows::Storage::Streams::IOutputStream^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          op = wrapper->_instance->SaveAsync(arg0);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IOutputStream^>(info[0])
        && info[1]->IsInt32())
      {
        try
        {
          ::Windows::Storage::Streams::IOutputStream^ arg0 = dynamic_cast<::Windows::Storage::Streams::IOutputStream^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::UI::Input::Inking::InkPersistenceFormat arg1 = static_cast<::Windows::UI::Input::Inking::InkPersistenceFormat>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          op = wrapper->_instance->SaveAsync(arg0,arg1);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

      auto opTask = create_task(op);
      uv_async_t* asyncToken = NodeUtils::Async::GetAsyncToken(info[info.Length() -1].As<Function>());

      opTask.then( [asyncToken] (task<unsigned int> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = Nan::New<Integer>(result);
              if (tryCatch.HasCaught())
              {
                error = Nan::To<Object>(tryCatch.Exception()).ToLocalChecked();
              }
              else
              {
                error = Undefined();
              }
              if (arg1.IsEmpty()) arg1 = Undefined();
            }
            Local<Value> args[] = {error, arg1};


            invokeCallback(_countof(args), args);
          });
        } catch (Platform::Exception^ exception) {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {
            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

            Local<Value> args[] = {error};
            invokeCallback(_countof(args), args);
          });
        }
      });
    }

    static void AddStroke(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeContainer^>(info.This())) {
        return;
      }

      InkStrokeContainer *wrapper = InkStrokeContainer::Unwrap<InkStrokeContainer>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStroke^>(info[0]))
      {
        try
        {
          ::Windows::UI::Input::Inking::InkStroke^ arg0 = UnwrapInkStroke(info[0]);
          
          wrapper->_instance->AddStroke(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 DeleteSelected(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeContainer^>(info.This())) {
        return;
      }

      InkStrokeContainer *wrapper = InkStrokeContainer::Unwrap<InkStrokeContainer>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Rect result;
          result = wrapper->_instance->DeleteSelected();
          info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void MoveSelected(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeContainer^>(info.This())) {
        return;
      }

      InkStrokeContainer *wrapper = InkStrokeContainer::Unwrap<InkStrokeContainer>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsPoint(info[0]))
      {
        try
        {
          ::Windows::Foundation::Point arg0 = NodeRT::Utils::PointFromJs(info[0]);
          
          ::Windows::Foundation::Rect result;
          result = wrapper->_instance->MoveSelected(arg0);
          info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void SelectWithPolyLine(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeContainer^>(info.This())) {
        return;
      }

      InkStrokeContainer *wrapper = InkStrokeContainer::Unwrap<InkStrokeContainer>(info.This());

      if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Point>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Point>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Point>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Foundation::Point>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsPoint(value);
                 },
                 [](Local<Value> value) -> ::Windows::Foundation::Point {
                   return NodeRT::Utils::PointFromJs(value);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Point>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          ::Windows::Foundation::Rect result;
          result = wrapper->_instance->SelectWithPolyLine(arg0);
          info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void SelectWithLine(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeContainer^>(info.This())) {
        return;
      }

      InkStrokeContainer *wrapper = InkStrokeContainer::Unwrap<InkStrokeContainer>(info.This());

      if (info.Length() == 2
        && NodeRT::Utils::IsPoint(info[0])
        && NodeRT::Utils::IsPoint(info[1]))
      {
        try
        {
          ::Windows::Foundation::Point arg0 = NodeRT::Utils::PointFromJs(info[0]);
          ::Windows::Foundation::Point arg1 = NodeRT::Utils::PointFromJs(info[1]);
          
          ::Windows::Foundation::Rect result;
          result = wrapper->_instance->SelectWithLine(arg0, arg1);
          info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void CopySelectedToClipboard(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeContainer^>(info.This())) {
        return;
      }

      InkStrokeContainer *wrapper = InkStrokeContainer::Unwrap<InkStrokeContainer>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->CopySelectedToClipboard();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void PasteFromClipboard(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeContainer^>(info.This())) {
        return;
      }

      InkStrokeContainer *wrapper = InkStrokeContainer::Unwrap<InkStrokeContainer>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsPoint(info[0]))
      {
        try
        {
          ::Windows::Foundation::Point arg0 = NodeRT::Utils::PointFromJs(info[0]);
          
          ::Windows::Foundation::Rect result;
          result = wrapper->_instance->PasteFromClipboard(arg0);
          info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void CanPasteFromClipboard(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeContainer^>(info.This())) {
        return;
      }

      InkStrokeContainer *wrapper = InkStrokeContainer::Unwrap<InkStrokeContainer>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          bool result;
          result = wrapper->_instance->CanPasteFromClipboard();
          info.GetReturnValue().Set(Nan::New<Boolean>(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void UpdateRecognitionResults(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeContainer^>(info.This())) {
        return;
      }

      InkStrokeContainer *wrapper = InkStrokeContainer::Unwrap<InkStrokeContainer>(info.This());

      if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::InkRecognitionResult^>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::InkRecognitionResult^>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::InkRecognitionResult^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVectorView<::Windows::UI::Input::Inking::InkRecognitionResult^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkRecognitionResult^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::UI::Input::Inking::InkRecognitionResult^ {
                   return UnwrapInkRecognitionResult(value);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::InkRecognitionResult^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          wrapper->_instance->UpdateRecognitionResults(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 GetStrokes(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeContainer^>(info.This())) {
        return;
      }

      InkStrokeContainer *wrapper = InkStrokeContainer::Unwrap<InkStrokeContainer>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::InkStroke^>^ result;
          result = wrapper->_instance->GetStrokes();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::InkStroke^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::InkStroke^ val) -> Local<Value> {
              return WrapInkStroke(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStroke^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::InkStroke^ {
              return UnwrapInkStroke(value);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetRecognitionResults(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeContainer^>(info.This())) {
        return;
      }

      InkStrokeContainer *wrapper = InkStrokeContainer::Unwrap<InkStrokeContainer>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::InkRecognitionResult^>^ result;
          result = wrapper->_instance->GetRecognitionResults();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::InkRecognitionResult^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::InkRecognitionResult^ val) -> Local<Value> {
              return WrapInkRecognitionResult(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkRecognitionResult^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::InkRecognitionResult^ {
              return UnwrapInkRecognitionResult(value);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void AddStrokes(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeContainer^>(info.This())) {
        return;
      }

      InkStrokeContainer *wrapper = InkStrokeContainer::Unwrap<InkStrokeContainer>(info.This());

      if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Windows::UI::Input::Inking::InkStroke^>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<::Windows::UI::Input::Inking::InkStroke^>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Windows::UI::Input::Inking::InkStroke^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::UI::Input::Inking::InkStroke^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStroke^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::UI::Input::Inking::InkStroke^ {
                   return UnwrapInkStroke(value);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Windows::UI::Input::Inking::InkStroke^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          wrapper->_instance->AddStrokes(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Clear(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeContainer^>(info.This())) {
        return;
      }

      InkStrokeContainer *wrapper = InkStrokeContainer::Unwrap<InkStrokeContainer>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->Clear();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetStrokeById(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeContainer^>(info.This())) {
        return;
      }

      InkStrokeContainer *wrapper = InkStrokeContainer::Unwrap<InkStrokeContainer>(info.This());

      if (info.Length() == 1
        && info[0]->IsUint32())
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          
          ::Windows::UI::Input::Inking::InkStroke^ result;
          result = wrapper->_instance->GetStrokeById(arg0);
          info.GetReturnValue().Set(WrapInkStroke(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 BoundingRectGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeContainer^>(info.This())) {
        return;
      }

      InkStrokeContainer *wrapper = InkStrokeContainer::Unwrap<InkStrokeContainer>(info.This());

      try  {
        ::Windows::Foundation::Rect result = wrapper->_instance->BoundingRect;
        info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::Inking::InkStrokeContainer^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInkStrokeContainer(::Windows::UI::Input::Inking::InkStrokeContainer^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::InkStrokeContainer^ UnwrapInkStrokeContainer(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkStrokeContainer::s_constructorTemplate;

  v8::Local<v8::Value> WrapInkStrokeContainer(::Windows::UI::Input::Inking::InkStrokeContainer^ 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>(InkStrokeContainer::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::Inking::InkStrokeContainer^ UnwrapInkStrokeContainer(Local<Value> value) {
     return InkStrokeContainer::Unwrap<InkStrokeContainer>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInkStrokeContainer(Local<Object> exports) {
    InkStrokeContainer::Init(exports);
  }

  class InkStrokeInput : 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>("InkStrokeInput").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);




          
          Nan::SetPrototypeMethod(localRef,"addListener", AddListener);
          Nan::SetPrototypeMethod(localRef,"on", AddListener);
          Nan::SetPrototypeMethod(localRef,"removeListener", RemoveListener);
          Nan::SetPrototypeMethod(localRef, "off", RemoveListener);

          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("inkPresenter").ToLocalChecked(), InkPresenterGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("InkStrokeInput").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      InkStrokeInput(::Windows::UI::Input::Inking::InkStrokeInput^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Input::Inking::InkStrokeInput^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeInput^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::Inking::InkStrokeInput^) 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());

      InkStrokeInput *wrapperInstance = new InkStrokeInput(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeInput^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Input::Inking::InkStrokeInput^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::Inking::InkStrokeInput^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapInkStrokeInput(winRtInstance));
    }





    static void InkPresenterGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeInput^>(info.This())) {
        return;
      }

      InkStrokeInput *wrapper = InkStrokeInput::Unwrap<InkStrokeInput>(info.This());

      try  {
        ::Windows::UI::Input::Inking::InkPresenter^ result = wrapper->_instance->InkPresenter;
        info.GetReturnValue().Set(WrapInkPresenter(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    static void AddListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"strokeCanceled", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeInput^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        InkStrokeInput *wrapper = InkStrokeInput::Unwrap<InkStrokeInput>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->StrokeCanceled::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Inking::InkStrokeInput^, ::Windows::UI::Core::PointerEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Inking::InkStrokeInput^ arg0, ::Windows::UI::Core::PointerEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapInkStrokeInput(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "PointerEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"strokeContinued", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeInput^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        InkStrokeInput *wrapper = InkStrokeInput::Unwrap<InkStrokeInput>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->StrokeContinued::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Inking::InkStrokeInput^, ::Windows::UI::Core::PointerEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Inking::InkStrokeInput^ arg0, ::Windows::UI::Core::PointerEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapInkStrokeInput(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "PointerEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"strokeEnded", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeInput^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        InkStrokeInput *wrapper = InkStrokeInput::Unwrap<InkStrokeInput>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->StrokeEnded::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Inking::InkStrokeInput^, ::Windows::UI::Core::PointerEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Inking::InkStrokeInput^ arg0, ::Windows::UI::Core::PointerEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapInkStrokeInput(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "PointerEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"strokeStarted", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeInput^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        InkStrokeInput *wrapper = InkStrokeInput::Unwrap<InkStrokeInput>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->StrokeStarted::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Inking::InkStrokeInput^, ::Windows::UI::Core::PointerEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Inking::InkStrokeInput^ arg0, ::Windows::UI::Core::PointerEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapInkStrokeInput(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "PointerEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
 else  {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Value> tokenMapVal = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());
      Local<Object> tokenMap;

      if (tokenMapVal.IsEmpty() || Nan::Equals(tokenMapVal, Undefined()).FromMaybe(false)) {
        tokenMap = Nan::New<Object>();
        NodeRT::Utils::SetHiddenValueWithObject(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked(), tokenMap);
      } else {
        tokenMap = Nan::To<Object>(tokenMapVal).ToLocalChecked();
      }

      Nan::Set(tokenMap, info[0], CreateOpaqueWrapper(::Windows::Foundation::PropertyValue::CreateInt64(registrationToken.Value)));
    }

    static void RemoveListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected a string and a callback")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      if ((!NodeRT::Utils::CaseInsenstiveEquals(L"strokeCanceled", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"strokeContinued", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"strokeEnded", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"strokeStarted", str))) {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Function> callback = info[1].As<Function>();
      Local<Value> tokenMap = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());

      if (tokenMap.IsEmpty() || Nan::Equals(tokenMap, Undefined()).FromMaybe(false)) {
        return;
      }

      Local<Value> opaqueWrapperObj =  Nan::Get(Nan::To<Object>(tokenMap).ToLocalChecked(), info[0]).ToLocalChecked();

      if (opaqueWrapperObj.IsEmpty() || Nan::Equals(opaqueWrapperObj,Undefined()).FromMaybe(false)) {
        return;
      }

      OpaqueWrapper *opaqueWrapper = OpaqueWrapper::Unwrap<OpaqueWrapper>(opaqueWrapperObj.As<Object>());

      long long tokenValue = (long long) opaqueWrapper->GetObjectInstance();
      ::Windows::Foundation::EventRegistrationToken registrationToken;
      registrationToken.Value = tokenValue;

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"strokeCanceled", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeInput^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          InkStrokeInput *wrapper = InkStrokeInput::Unwrap<InkStrokeInput>(info.This());
          wrapper->_instance->StrokeCanceled::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"strokeContinued", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeInput^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          InkStrokeInput *wrapper = InkStrokeInput::Unwrap<InkStrokeInput>(info.This());
          wrapper->_instance->StrokeContinued::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"strokeEnded", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeInput^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          InkStrokeInput *wrapper = InkStrokeInput::Unwrap<InkStrokeInput>(info.This());
          wrapper->_instance->StrokeEnded::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"strokeStarted", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeInput^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          InkStrokeInput *wrapper = InkStrokeInput::Unwrap<InkStrokeInput>(info.This());
          wrapper->_instance->StrokeStarted::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

      Nan::Delete(Nan::To<Object>(tokenMap).ToLocalChecked(), Nan::To<String>(info[0]).ToLocalChecked());
    }
    private:
      ::Windows::UI::Input::Inking::InkStrokeInput^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInkStrokeInput(::Windows::UI::Input::Inking::InkStrokeInput^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::InkStrokeInput^ UnwrapInkStrokeInput(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkStrokeInput::s_constructorTemplate;

  v8::Local<v8::Value> WrapInkStrokeInput(::Windows::UI::Input::Inking::InkStrokeInput^ 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>(InkStrokeInput::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::Inking::InkStrokeInput^ UnwrapInkStrokeInput(Local<Value> value) {
     return InkStrokeInput::Unwrap<InkStrokeInput>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInkStrokeInput(Local<Object> exports) {
    InkStrokeInput::Init(exports);
  }

  class InkStrokeRenderingSegment : 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>("InkStrokeRenderingSegment").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("bezierControlPoint1").ToLocalChecked(), BezierControlPoint1Getter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("bezierControlPoint2").ToLocalChecked(), BezierControlPoint2Getter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("position").ToLocalChecked(), PositionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pressure").ToLocalChecked(), PressureGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("tiltX").ToLocalChecked(), TiltXGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("tiltY").ToLocalChecked(), TiltYGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("twist").ToLocalChecked(), TwistGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("InkStrokeRenderingSegment").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      InkStrokeRenderingSegment(::Windows::UI::Input::Inking::InkStrokeRenderingSegment^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Input::Inking::InkStrokeRenderingSegment^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeRenderingSegment^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::Inking::InkStrokeRenderingSegment^) 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());

      InkStrokeRenderingSegment *wrapperInstance = new InkStrokeRenderingSegment(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeRenderingSegment^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Input::Inking::InkStrokeRenderingSegment^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::Inking::InkStrokeRenderingSegment^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapInkStrokeRenderingSegment(winRtInstance));
    }





    static void BezierControlPoint1Getter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeRenderingSegment^>(info.This())) {
        return;
      }

      InkStrokeRenderingSegment *wrapper = InkStrokeRenderingSegment::Unwrap<InkStrokeRenderingSegment>(info.This());

      try  {
        ::Windows::Foundation::Point result = wrapper->_instance->BezierControlPoint1;
        info.GetReturnValue().Set(NodeRT::Utils::PointToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BezierControlPoint2Getter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeRenderingSegment^>(info.This())) {
        return;
      }

      InkStrokeRenderingSegment *wrapper = InkStrokeRenderingSegment::Unwrap<InkStrokeRenderingSegment>(info.This());

      try  {
        ::Windows::Foundation::Point result = wrapper->_instance->BezierControlPoint2;
        info.GetReturnValue().Set(NodeRT::Utils::PointToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PositionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeRenderingSegment^>(info.This())) {
        return;
      }

      InkStrokeRenderingSegment *wrapper = InkStrokeRenderingSegment::Unwrap<InkStrokeRenderingSegment>(info.This());

      try  {
        ::Windows::Foundation::Point result = wrapper->_instance->Position;
        info.GetReturnValue().Set(NodeRT::Utils::PointToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PressureGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeRenderingSegment^>(info.This())) {
        return;
      }

      InkStrokeRenderingSegment *wrapper = InkStrokeRenderingSegment::Unwrap<InkStrokeRenderingSegment>(info.This());

      try  {
        float result = wrapper->_instance->Pressure;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TiltXGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeRenderingSegment^>(info.This())) {
        return;
      }

      InkStrokeRenderingSegment *wrapper = InkStrokeRenderingSegment::Unwrap<InkStrokeRenderingSegment>(info.This());

      try  {
        float result = wrapper->_instance->TiltX;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TiltYGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeRenderingSegment^>(info.This())) {
        return;
      }

      InkStrokeRenderingSegment *wrapper = InkStrokeRenderingSegment::Unwrap<InkStrokeRenderingSegment>(info.This());

      try  {
        float result = wrapper->_instance->TiltY;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TwistGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokeRenderingSegment^>(info.This())) {
        return;
      }

      InkStrokeRenderingSegment *wrapper = InkStrokeRenderingSegment::Unwrap<InkStrokeRenderingSegment>(info.This());

      try  {
        float result = wrapper->_instance->Twist;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::Inking::InkStrokeRenderingSegment^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInkStrokeRenderingSegment(::Windows::UI::Input::Inking::InkStrokeRenderingSegment^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::InkStrokeRenderingSegment^ UnwrapInkStrokeRenderingSegment(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkStrokeRenderingSegment::s_constructorTemplate;

  v8::Local<v8::Value> WrapInkStrokeRenderingSegment(::Windows::UI::Input::Inking::InkStrokeRenderingSegment^ 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>(InkStrokeRenderingSegment::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::Inking::InkStrokeRenderingSegment^ UnwrapInkStrokeRenderingSegment(Local<Value> value) {
     return InkStrokeRenderingSegment::Unwrap<InkStrokeRenderingSegment>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInkStrokeRenderingSegment(Local<Object> exports) {
    InkStrokeRenderingSegment::Init(exports);
  }

  class InkStrokesCollectedEventArgs : 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>("InkStrokesCollectedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("strokes").ToLocalChecked(), StrokesGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("InkStrokesCollectedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      InkStrokesCollectedEventArgs(::Windows::UI::Input::Inking::InkStrokesCollectedEventArgs^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Input::Inking::InkStrokesCollectedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokesCollectedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::Inking::InkStrokesCollectedEventArgs^) 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());

      InkStrokesCollectedEventArgs *wrapperInstance = new InkStrokesCollectedEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokesCollectedEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Input::Inking::InkStrokesCollectedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::Inking::InkStrokesCollectedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapInkStrokesCollectedEventArgs(winRtInstance));
    }





    static void StrokesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokesCollectedEventArgs^>(info.This())) {
        return;
      }

      InkStrokesCollectedEventArgs *wrapper = InkStrokesCollectedEventArgs::Unwrap<InkStrokesCollectedEventArgs>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::InkStroke^>^ result = wrapper->_instance->Strokes;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::InkStroke^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::InkStroke^ val) -> Local<Value> {
              return WrapInkStroke(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStroke^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::InkStroke^ {
              return UnwrapInkStroke(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::Inking::InkStrokesCollectedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInkStrokesCollectedEventArgs(::Windows::UI::Input::Inking::InkStrokesCollectedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::InkStrokesCollectedEventArgs^ UnwrapInkStrokesCollectedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkStrokesCollectedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapInkStrokesCollectedEventArgs(::Windows::UI::Input::Inking::InkStrokesCollectedEventArgs^ 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>(InkStrokesCollectedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::Inking::InkStrokesCollectedEventArgs^ UnwrapInkStrokesCollectedEventArgs(Local<Value> value) {
     return InkStrokesCollectedEventArgs::Unwrap<InkStrokesCollectedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInkStrokesCollectedEventArgs(Local<Object> exports) {
    InkStrokesCollectedEventArgs::Init(exports);
  }

  class InkStrokesErasedEventArgs : 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>("InkStrokesErasedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("strokes").ToLocalChecked(), StrokesGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("InkStrokesErasedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      InkStrokesErasedEventArgs(::Windows::UI::Input::Inking::InkStrokesErasedEventArgs^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Input::Inking::InkStrokesErasedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokesErasedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::Inking::InkStrokesErasedEventArgs^) 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());

      InkStrokesErasedEventArgs *wrapperInstance = new InkStrokesErasedEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokesErasedEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Input::Inking::InkStrokesErasedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::Inking::InkStrokesErasedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapInkStrokesErasedEventArgs(winRtInstance));
    }





    static void StrokesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStrokesErasedEventArgs^>(info.This())) {
        return;
      }

      InkStrokesErasedEventArgs *wrapper = InkStrokesErasedEventArgs::Unwrap<InkStrokesErasedEventArgs>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::InkStroke^>^ result = wrapper->_instance->Strokes;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::InkStroke^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::InkStroke^ val) -> Local<Value> {
              return WrapInkStroke(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStroke^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::InkStroke^ {
              return UnwrapInkStroke(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::Inking::InkStrokesErasedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInkStrokesErasedEventArgs(::Windows::UI::Input::Inking::InkStrokesErasedEventArgs^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::InkStrokesErasedEventArgs^ UnwrapInkStrokesErasedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkStrokesErasedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapInkStrokesErasedEventArgs(::Windows::UI::Input::Inking::InkStrokesErasedEventArgs^ 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>(InkStrokesErasedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::Inking::InkStrokesErasedEventArgs^ UnwrapInkStrokesErasedEventArgs(Local<Value> value) {
     return InkStrokesErasedEventArgs::Unwrap<InkStrokesErasedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInkStrokesErasedEventArgs(Local<Object> exports) {
    InkStrokesErasedEventArgs::Init(exports);
  }

  class InkSynchronizer : 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>("InkSynchronizer").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "beginDry", BeginDry);
            Nan::SetPrototypeMethod(localRef, "endDry", EndDry);
          




        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("InkSynchronizer").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      InkSynchronizer(::Windows::UI::Input::Inking::InkSynchronizer^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Input::Inking::InkSynchronizer^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkSynchronizer^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::Inking::InkSynchronizer^) 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());

      InkSynchronizer *wrapperInstance = new InkSynchronizer(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkSynchronizer^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Input::Inking::InkSynchronizer^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::Inking::InkSynchronizer^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapInkSynchronizer(winRtInstance));
    }


    static void BeginDry(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkSynchronizer^>(info.This())) {
        return;
      }

      InkSynchronizer *wrapper = InkSynchronizer::Unwrap<InkSynchronizer>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::InkStroke^>^ result;
          result = wrapper->_instance->BeginDry();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::InkStroke^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::InkStroke^ val) -> Local<Value> {
              return WrapInkStroke(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkStroke^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::InkStroke^ {
              return UnwrapInkStroke(value);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void EndDry(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkSynchronizer^>(info.This())) {
        return;
      }

      InkSynchronizer *wrapper = InkSynchronizer::Unwrap<InkSynchronizer>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->EndDry();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





    private:
      ::Windows::UI::Input::Inking::InkSynchronizer^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInkSynchronizer(::Windows::UI::Input::Inking::InkSynchronizer^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::InkSynchronizer^ UnwrapInkSynchronizer(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkSynchronizer::s_constructorTemplate;

  v8::Local<v8::Value> WrapInkSynchronizer(::Windows::UI::Input::Inking::InkSynchronizer^ 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>(InkSynchronizer::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::Inking::InkSynchronizer^ UnwrapInkSynchronizer(Local<Value> value) {
     return InkSynchronizer::Unwrap<InkSynchronizer>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInkSynchronizer(Local<Object> exports) {
    InkSynchronizer::Init(exports);
  }

  class InkUnprocessedInput : 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>("InkUnprocessedInput").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);




          
          Nan::SetPrototypeMethod(localRef,"addListener", AddListener);
          Nan::SetPrototypeMethod(localRef,"on", AddListener);
          Nan::SetPrototypeMethod(localRef,"removeListener", RemoveListener);
          Nan::SetPrototypeMethod(localRef, "off", RemoveListener);

          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("inkPresenter").ToLocalChecked(), InkPresenterGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("InkUnprocessedInput").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      InkUnprocessedInput(::Windows::UI::Input::Inking::InkUnprocessedInput^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Input::Inking::InkUnprocessedInput^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkUnprocessedInput^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::Inking::InkUnprocessedInput^) 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());

      InkUnprocessedInput *wrapperInstance = new InkUnprocessedInput(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkUnprocessedInput^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Input::Inking::InkUnprocessedInput^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::Inking::InkUnprocessedInput^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapInkUnprocessedInput(winRtInstance));
    }





    static void InkPresenterGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkUnprocessedInput^>(info.This())) {
        return;
      }

      InkUnprocessedInput *wrapper = InkUnprocessedInput::Unwrap<InkUnprocessedInput>(info.This());

      try  {
        ::Windows::UI::Input::Inking::InkPresenter^ result = wrapper->_instance->InkPresenter;
        info.GetReturnValue().Set(WrapInkPresenter(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    static void AddListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerEntered", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkUnprocessedInput^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        InkUnprocessedInput *wrapper = InkUnprocessedInput::Unwrap<InkUnprocessedInput>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PointerEntered::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Inking::InkUnprocessedInput^, ::Windows::UI::Core::PointerEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Inking::InkUnprocessedInput^ arg0, ::Windows::UI::Core::PointerEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapInkUnprocessedInput(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "PointerEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerExited", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkUnprocessedInput^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        InkUnprocessedInput *wrapper = InkUnprocessedInput::Unwrap<InkUnprocessedInput>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PointerExited::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Inking::InkUnprocessedInput^, ::Windows::UI::Core::PointerEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Inking::InkUnprocessedInput^ arg0, ::Windows::UI::Core::PointerEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapInkUnprocessedInput(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "PointerEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerHovered", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkUnprocessedInput^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        InkUnprocessedInput *wrapper = InkUnprocessedInput::Unwrap<InkUnprocessedInput>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PointerHovered::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Inking::InkUnprocessedInput^, ::Windows::UI::Core::PointerEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Inking::InkUnprocessedInput^ arg0, ::Windows::UI::Core::PointerEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapInkUnprocessedInput(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "PointerEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerLost", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkUnprocessedInput^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        InkUnprocessedInput *wrapper = InkUnprocessedInput::Unwrap<InkUnprocessedInput>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PointerLost::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Inking::InkUnprocessedInput^, ::Windows::UI::Core::PointerEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Inking::InkUnprocessedInput^ arg0, ::Windows::UI::Core::PointerEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapInkUnprocessedInput(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "PointerEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerMoved", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkUnprocessedInput^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        InkUnprocessedInput *wrapper = InkUnprocessedInput::Unwrap<InkUnprocessedInput>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PointerMoved::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Inking::InkUnprocessedInput^, ::Windows::UI::Core::PointerEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Inking::InkUnprocessedInput^ arg0, ::Windows::UI::Core::PointerEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapInkUnprocessedInput(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "PointerEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerPressed", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkUnprocessedInput^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        InkUnprocessedInput *wrapper = InkUnprocessedInput::Unwrap<InkUnprocessedInput>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PointerPressed::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Inking::InkUnprocessedInput^, ::Windows::UI::Core::PointerEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Inking::InkUnprocessedInput^ arg0, ::Windows::UI::Core::PointerEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapInkUnprocessedInput(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "PointerEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerReleased", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkUnprocessedInput^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        InkUnprocessedInput *wrapper = InkUnprocessedInput::Unwrap<InkUnprocessedInput>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PointerReleased::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::Input::Inking::InkUnprocessedInput^, ::Windows::UI::Core::PointerEventArgs^>(
            [callbackObjPtr](::Windows::UI::Input::Inking::InkUnprocessedInput^ arg0, ::Windows::UI::Core::PointerEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapInkUnprocessedInput(arg0);
                  wrappedArg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.Core", "PointerEventArgs", arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
 else  {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Value> tokenMapVal = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());
      Local<Object> tokenMap;

      if (tokenMapVal.IsEmpty() || Nan::Equals(tokenMapVal, Undefined()).FromMaybe(false)) {
        tokenMap = Nan::New<Object>();
        NodeRT::Utils::SetHiddenValueWithObject(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked(), tokenMap);
      } else {
        tokenMap = Nan::To<Object>(tokenMapVal).ToLocalChecked();
      }

      Nan::Set(tokenMap, info[0], CreateOpaqueWrapper(::Windows::Foundation::PropertyValue::CreateInt64(registrationToken.Value)));
    }

    static void RemoveListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected a string and a callback")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      if ((!NodeRT::Utils::CaseInsenstiveEquals(L"pointerEntered", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"pointerExited", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"pointerHovered", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"pointerLost", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"pointerMoved", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"pointerPressed", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"pointerReleased", str))) {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Function> callback = info[1].As<Function>();
      Local<Value> tokenMap = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());

      if (tokenMap.IsEmpty() || Nan::Equals(tokenMap, Undefined()).FromMaybe(false)) {
        return;
      }

      Local<Value> opaqueWrapperObj =  Nan::Get(Nan::To<Object>(tokenMap).ToLocalChecked(), info[0]).ToLocalChecked();

      if (opaqueWrapperObj.IsEmpty() || Nan::Equals(opaqueWrapperObj,Undefined()).FromMaybe(false)) {
        return;
      }

      OpaqueWrapper *opaqueWrapper = OpaqueWrapper::Unwrap<OpaqueWrapper>(opaqueWrapperObj.As<Object>());

      long long tokenValue = (long long) opaqueWrapper->GetObjectInstance();
      ::Windows::Foundation::EventRegistrationToken registrationToken;
      registrationToken.Value = tokenValue;

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerEntered", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkUnprocessedInput^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          InkUnprocessedInput *wrapper = InkUnprocessedInput::Unwrap<InkUnprocessedInput>(info.This());
          wrapper->_instance->PointerEntered::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerExited", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkUnprocessedInput^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          InkUnprocessedInput *wrapper = InkUnprocessedInput::Unwrap<InkUnprocessedInput>(info.This());
          wrapper->_instance->PointerExited::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerHovered", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkUnprocessedInput^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          InkUnprocessedInput *wrapper = InkUnprocessedInput::Unwrap<InkUnprocessedInput>(info.This());
          wrapper->_instance->PointerHovered::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerLost", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkUnprocessedInput^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          InkUnprocessedInput *wrapper = InkUnprocessedInput::Unwrap<InkUnprocessedInput>(info.This());
          wrapper->_instance->PointerLost::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerMoved", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkUnprocessedInput^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          InkUnprocessedInput *wrapper = InkUnprocessedInput::Unwrap<InkUnprocessedInput>(info.This());
          wrapper->_instance->PointerMoved::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerPressed", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkUnprocessedInput^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          InkUnprocessedInput *wrapper = InkUnprocessedInput::Unwrap<InkUnprocessedInput>(info.This());
          wrapper->_instance->PointerPressed::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"pointerReleased", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::InkUnprocessedInput^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          InkUnprocessedInput *wrapper = InkUnprocessedInput::Unwrap<InkUnprocessedInput>(info.This());
          wrapper->_instance->PointerReleased::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

      Nan::Delete(Nan::To<Object>(tokenMap).ToLocalChecked(), Nan::To<String>(info[0]).ToLocalChecked());
    }
    private:
      ::Windows::UI::Input::Inking::InkUnprocessedInput^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInkUnprocessedInput(::Windows::UI::Input::Inking::InkUnprocessedInput^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::InkUnprocessedInput^ UnwrapInkUnprocessedInput(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkUnprocessedInput::s_constructorTemplate;

  v8::Local<v8::Value> WrapInkUnprocessedInput(::Windows::UI::Input::Inking::InkUnprocessedInput^ 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>(InkUnprocessedInput::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::Inking::InkUnprocessedInput^ UnwrapInkUnprocessedInput(Local<Value> value) {
     return InkUnprocessedInput::Unwrap<InkUnprocessedInput>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInkUnprocessedInput(Local<Object> exports) {
    InkUnprocessedInput::Init(exports);
  }

  class PenAndInkSettings : 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>("PenAndInkSettings").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("fontFamilyName").ToLocalChecked(), FontFamilyNameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("handwritingLineHeight").ToLocalChecked(), HandwritingLineHeightGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isHandwritingDirectlyIntoTextFieldEnabled").ToLocalChecked(), IsHandwritingDirectlyIntoTextFieldEnabledGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isTouchHandwritingEnabled").ToLocalChecked(), IsTouchHandwritingEnabledGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("penHandedness").ToLocalChecked(), PenHandednessGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("userConsentsToHandwritingTelemetryCollection").ToLocalChecked(), UserConsentsToHandwritingTelemetryCollectionGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetMethod(constructor, "getDefault", GetDefault);


        Nan::Set(exports, Nan::New<String>("PenAndInkSettings").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      PenAndInkSettings(::Windows::UI::Input::Inking::PenAndInkSettings^ instance) {
        _instance = instance;
      }

      
    static void New(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::UI::Input::Inking::PenAndInkSettings^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::PenAndInkSettings^>(info[0])) {
        try {
          winRtInstance = (::Windows::UI::Input::Inking::PenAndInkSettings^) 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());

      PenAndInkSettings *wrapperInstance = new PenAndInkSettings(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::PenAndInkSettings^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::UI::Input::Inking::PenAndInkSettings^ winRtInstance;
      try {
        winRtInstance = (::Windows::UI::Input::Inking::PenAndInkSettings^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapPenAndInkSettings(winRtInstance));
    }





    static void GetDefault(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::UI::Input::Inking::PenAndInkSettings^ result;
          result = ::Windows::UI::Input::Inking::PenAndInkSettings::GetDefault();
          info.GetReturnValue().Set(WrapPenAndInkSettings(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 FontFamilyNameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::PenAndInkSettings^>(info.This())) {
        return;
      }

      PenAndInkSettings *wrapper = PenAndInkSettings::Unwrap<PenAndInkSettings>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->FontFamilyName;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void HandwritingLineHeightGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::PenAndInkSettings^>(info.This())) {
        return;
      }

      PenAndInkSettings *wrapper = PenAndInkSettings::Unwrap<PenAndInkSettings>(info.This());

      try  {
        ::Windows::UI::Input::Inking::HandwritingLineHeight result = wrapper->_instance->HandwritingLineHeight;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsHandwritingDirectlyIntoTextFieldEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::PenAndInkSettings^>(info.This())) {
        return;
      }

      PenAndInkSettings *wrapper = PenAndInkSettings::Unwrap<PenAndInkSettings>(info.This());

      try  {
        bool result = wrapper->_instance->IsHandwritingDirectlyIntoTextFieldEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsTouchHandwritingEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::PenAndInkSettings^>(info.This())) {
        return;
      }

      PenAndInkSettings *wrapper = PenAndInkSettings::Unwrap<PenAndInkSettings>(info.This());

      try  {
        bool result = wrapper->_instance->IsTouchHandwritingEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PenHandednessGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::PenAndInkSettings^>(info.This())) {
        return;
      }

      PenAndInkSettings *wrapper = PenAndInkSettings::Unwrap<PenAndInkSettings>(info.This());

      try  {
        ::Windows::UI::Input::Inking::PenHandedness result = wrapper->_instance->PenHandedness;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void UserConsentsToHandwritingTelemetryCollectionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::PenAndInkSettings^>(info.This())) {
        return;
      }

      PenAndInkSettings *wrapper = PenAndInkSettings::Unwrap<PenAndInkSettings>(info.This());

      try  {
        bool result = wrapper->_instance->UserConsentsToHandwritingTelemetryCollection;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Input::Inking::PenAndInkSettings^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPenAndInkSettings(::Windows::UI::Input::Inking::PenAndInkSettings^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::PenAndInkSettings^ UnwrapPenAndInkSettings(Local<Value> value);
  };

  Persistent<FunctionTemplate> PenAndInkSettings::s_constructorTemplate;

  v8::Local<v8::Value> WrapPenAndInkSettings(::Windows::UI::Input::Inking::PenAndInkSettings^ 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>(PenAndInkSettings::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::Input::Inking::PenAndInkSettings^ UnwrapPenAndInkSettings(Local<Value> value) {
     return PenAndInkSettings::Unwrap<PenAndInkSettings>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPenAndInkSettings(Local<Object> exports) {
    PenAndInkSettings::Init(exports);
  }


} } } } } 

NAN_MODULE_INIT(init) {
  // We ignore failures for now since it probably means that
  // the initialization already happened for STA, and that's cool

  CoInitializeEx(nullptr, COINIT_MULTITHREADED);

  /*
  if (FAILED(CoInitializeEx(nullptr, COINIT_MULTITHREADED))) {
    Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"error in CoInitializeEx()")));
    return;
  }
  */

      NodeRT::Windows::UI::Input::Inking::InitHandwritingLineHeightEnum(target);
      NodeRT::Windows::UI::Input::Inking::InitInkDrawingAttributesKindEnum(target);
      NodeRT::Windows::UI::Input::Inking::InitInkHighContrastAdjustmentEnum(target);
      NodeRT::Windows::UI::Input::Inking::InitInkInputProcessingModeEnum(target);
      NodeRT::Windows::UI::Input::Inking::InitInkInputRightDragActionEnum(target);
      NodeRT::Windows::UI::Input::Inking::InitInkManipulationModeEnum(target);
      NodeRT::Windows::UI::Input::Inking::InitInkPersistenceFormatEnum(target);
      NodeRT::Windows::UI::Input::Inking::InitInkPresenterPredefinedConfigurationEnum(target);
      NodeRT::Windows::UI::Input::Inking::InitInkPresenterStencilKindEnum(target);
      NodeRT::Windows::UI::Input::Inking::InitInkRecognitionTargetEnum(target);
      NodeRT::Windows::UI::Input::Inking::InitPenHandednessEnum(target);
      NodeRT::Windows::UI::Input::Inking::InitPenTipShapeEnum(target);
      NodeRT::Windows::UI::Input::Inking::InitIInkPointFactory(target);
      NodeRT::Windows::UI::Input::Inking::InitIInkPresenterRulerFactory(target);
      NodeRT::Windows::UI::Input::Inking::InitIInkPresenterStencil(target);
      NodeRT::Windows::UI::Input::Inking::InitIInkRecognizerContainer(target);
      NodeRT::Windows::UI::Input::Inking::InitIInkStrokeContainer(target);
      NodeRT::Windows::UI::Input::Inking::InitInkDrawingAttributes(target);
      NodeRT::Windows::UI::Input::Inking::InitInkDrawingAttributesPencilProperties(target);
      NodeRT::Windows::UI::Input::Inking::InitInkInputConfiguration(target);
      NodeRT::Windows::UI::Input::Inking::InitInkInputProcessingConfiguration(target);
      NodeRT::Windows::UI::Input::Inking::InitInkManager(target);
      NodeRT::Windows::UI::Input::Inking::InitInkModelerAttributes(target);
      NodeRT::Windows::UI::Input::Inking::InitInkPoint(target);
      NodeRT::Windows::UI::Input::Inking::InitInkPresenter(target);
      NodeRT::Windows::UI::Input::Inking::InitInkPresenterProtractor(target);
      NodeRT::Windows::UI::Input::Inking::InitInkPresenterRuler(target);
      NodeRT::Windows::UI::Input::Inking::InitInkRecognitionResult(target);
      NodeRT::Windows::UI::Input::Inking::InitInkRecognizer(target);
      NodeRT::Windows::UI::Input::Inking::InitInkRecognizerContainer(target);
      NodeRT::Windows::UI::Input::Inking::InitInkStroke(target);
      NodeRT::Windows::UI::Input::Inking::InitInkStrokeBuilder(target);
      NodeRT::Windows::UI::Input::Inking::InitInkStrokeContainer(target);
      NodeRT::Windows::UI::Input::Inking::InitInkStrokeInput(target);
      NodeRT::Windows::UI::Input::Inking::InitInkStrokeRenderingSegment(target);
      NodeRT::Windows::UI::Input::Inking::InitInkStrokesCollectedEventArgs(target);
      NodeRT::Windows::UI::Input::Inking::InitInkStrokesErasedEventArgs(target);
      NodeRT::Windows::UI::Input::Inking::InitInkSynchronizer(target);
      NodeRT::Windows::UI::Input::Inking::InitInkUnprocessedInput(target);
      NodeRT::Windows::UI::Input::Inking::InitPenAndInkSettings(target);


  NodeRT::Utils::RegisterNameSpace("Windows.UI.Input.Inking", target);
}



NODE_MODULE(binding, init)