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

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

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

#using <Windows.WinMD>

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

const char* REGISTRATION_TOKEN_MAP_PROPERTY_NAME = "__registrationTokenMap__";

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

namespace NodeRT { namespace Windows { namespace UI { namespace Input { namespace Inking { namespace Analysis { 
  v8::Local<v8::Value> WrapIInkAnalysisNode(::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^ wintRtInstance);
  ::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^ UnwrapIInkAnalysisNode(Local<Value> value);
  
  v8::Local<v8::Value> WrapIInkAnalyzerFactory(::Windows::UI::Input::Inking::Analysis::IInkAnalyzerFactory^ wintRtInstance);
  ::Windows::UI::Input::Inking::Analysis::IInkAnalyzerFactory^ UnwrapIInkAnalyzerFactory(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkAnalysisInkBullet(::Windows::UI::Input::Inking::Analysis::InkAnalysisInkBullet^ wintRtInstance);
  ::Windows::UI::Input::Inking::Analysis::InkAnalysisInkBullet^ UnwrapInkAnalysisInkBullet(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkAnalysisInkDrawing(::Windows::UI::Input::Inking::Analysis::InkAnalysisInkDrawing^ wintRtInstance);
  ::Windows::UI::Input::Inking::Analysis::InkAnalysisInkDrawing^ UnwrapInkAnalysisInkDrawing(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkAnalysisInkWord(::Windows::UI::Input::Inking::Analysis::InkAnalysisInkWord^ wintRtInstance);
  ::Windows::UI::Input::Inking::Analysis::InkAnalysisInkWord^ UnwrapInkAnalysisInkWord(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkAnalysisLine(::Windows::UI::Input::Inking::Analysis::InkAnalysisLine^ wintRtInstance);
  ::Windows::UI::Input::Inking::Analysis::InkAnalysisLine^ UnwrapInkAnalysisLine(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkAnalysisListItem(::Windows::UI::Input::Inking::Analysis::InkAnalysisListItem^ wintRtInstance);
  ::Windows::UI::Input::Inking::Analysis::InkAnalysisListItem^ UnwrapInkAnalysisListItem(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkAnalysisNode(::Windows::UI::Input::Inking::Analysis::InkAnalysisNode^ wintRtInstance);
  ::Windows::UI::Input::Inking::Analysis::InkAnalysisNode^ UnwrapInkAnalysisNode(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkAnalysisParagraph(::Windows::UI::Input::Inking::Analysis::InkAnalysisParagraph^ wintRtInstance);
  ::Windows::UI::Input::Inking::Analysis::InkAnalysisParagraph^ UnwrapInkAnalysisParagraph(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkAnalysisResult(::Windows::UI::Input::Inking::Analysis::InkAnalysisResult^ wintRtInstance);
  ::Windows::UI::Input::Inking::Analysis::InkAnalysisResult^ UnwrapInkAnalysisResult(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkAnalysisRoot(::Windows::UI::Input::Inking::Analysis::InkAnalysisRoot^ wintRtInstance);
  ::Windows::UI::Input::Inking::Analysis::InkAnalysisRoot^ UnwrapInkAnalysisRoot(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkAnalysisWritingRegion(::Windows::UI::Input::Inking::Analysis::InkAnalysisWritingRegion^ wintRtInstance);
  ::Windows::UI::Input::Inking::Analysis::InkAnalysisWritingRegion^ UnwrapInkAnalysisWritingRegion(Local<Value> value);
  
  v8::Local<v8::Value> WrapInkAnalyzer(::Windows::UI::Input::Inking::Analysis::InkAnalyzer^ wintRtInstance);
  ::Windows::UI::Input::Inking::Analysis::InkAnalyzer^ UnwrapInkAnalyzer(Local<Value> value);
  



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

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

    Nan::Set(exports, Nan::New<String>("InkAnalysisDrawingKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("drawing").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisDrawingKind::Drawing)));
    Nan::Set(enumObject, Nan::New<String>("circle").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisDrawingKind::Circle)));
    Nan::Set(enumObject, Nan::New<String>("ellipse").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisDrawingKind::Ellipse)));
    Nan::Set(enumObject, Nan::New<String>("triangle").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisDrawingKind::Triangle)));
    Nan::Set(enumObject, Nan::New<String>("isoscelesTriangle").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisDrawingKind::IsoscelesTriangle)));
    Nan::Set(enumObject, Nan::New<String>("equilateralTriangle").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisDrawingKind::EquilateralTriangle)));
    Nan::Set(enumObject, Nan::New<String>("rightTriangle").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisDrawingKind::RightTriangle)));
    Nan::Set(enumObject, Nan::New<String>("quadrilateral").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisDrawingKind::Quadrilateral)));
    Nan::Set(enumObject, Nan::New<String>("rectangle").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisDrawingKind::Rectangle)));
    Nan::Set(enumObject, Nan::New<String>("square").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisDrawingKind::Square)));
    Nan::Set(enumObject, Nan::New<String>("diamond").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisDrawingKind::Diamond)));
    Nan::Set(enumObject, Nan::New<String>("trapezoid").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisDrawingKind::Trapezoid)));
    Nan::Set(enumObject, Nan::New<String>("parallelogram").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisDrawingKind::Parallelogram)));
    Nan::Set(enumObject, Nan::New<String>("pentagon").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisDrawingKind::Pentagon)));
    Nan::Set(enumObject, Nan::New<String>("hexagon").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisDrawingKind::Hexagon)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("InkAnalysisNodeKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("unclassifiedInk").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisNodeKind::UnclassifiedInk)));
    Nan::Set(enumObject, Nan::New<String>("root").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisNodeKind::Root)));
    Nan::Set(enumObject, Nan::New<String>("writingRegion").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisNodeKind::WritingRegion)));
    Nan::Set(enumObject, Nan::New<String>("paragraph").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisNodeKind::Paragraph)));
    Nan::Set(enumObject, Nan::New<String>("line").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisNodeKind::Line)));
    Nan::Set(enumObject, Nan::New<String>("inkWord").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisNodeKind::InkWord)));
    Nan::Set(enumObject, Nan::New<String>("inkBullet").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisNodeKind::InkBullet)));
    Nan::Set(enumObject, Nan::New<String>("inkDrawing").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisNodeKind::InkDrawing)));
    Nan::Set(enumObject, Nan::New<String>("listItem").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisNodeKind::ListItem)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("InkAnalysisStatus").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("updated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisStatus::Updated)));
    Nan::Set(enumObject, Nan::New<String>("unchanged").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisStatus::Unchanged)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("InkAnalysisStrokeKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("auto").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisStrokeKind::Auto)));
    Nan::Set(enumObject, Nan::New<String>("writing").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisStrokeKind::Writing)));
    Nan::Set(enumObject, Nan::New<String>("drawing").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::Input::Inking::Analysis::InkAnalysisStrokeKind::Drawing)));
  }


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

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


          
            Nan::SetPrototypeMethod(localRef, "getStrokeIds", GetStrokeIds);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("boundingRect").ToLocalChecked(), BoundingRectGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("children").ToLocalChecked(), ChildrenGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("id").ToLocalChecked(), IdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("parent").ToLocalChecked(), ParentGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("rotatedBoundingRect").ToLocalChecked(), RotatedBoundingRectGetter);

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



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

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

    private:

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


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

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

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


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

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<unsigned int>^ result;
          result = wrapper->_instance->GetStrokeIds();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned int>::CreateVectorViewWrapper(result, 
            [](unsigned int val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsUint32();
            },
            [](Local<Value> value) -> unsigned int {
              return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
            }
          ));
          return;
        } catch (Platform::Exception ^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::Analysis::IInkAnalysisNode^>(info.This())) {
        return;
      }

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>^ result = wrapper->_instance->Children;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^ val) -> Local<Value> {
              return WrapIInkAnalysisNode(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^ {
              return UnwrapIInkAnalysisNode(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

      try  {
        ::Windows::UI::Input::Inking::Analysis::InkAnalysisNodeKind 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 ParentGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Foundation::Point>^ result = wrapper->_instance->RotatedBoundingRect;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Foundation::Point>::CreateVectorViewWrapper(result, 
            [](::Windows::Foundation::Point val) -> Local<Value> {
              return NodeRT::Utils::PointToJs(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsPoint(value);
            },
            [](Local<Value> value) -> ::Windows::Foundation::Point {
              return NodeRT::Utils::PointFromJs(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


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

      friend v8::Local<v8::Value> WrapIInkAnalysisNode(::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^ UnwrapIInkAnalysisNode(Local<Value> value);
  };

  Persistent<FunctionTemplate> IInkAnalysisNode::s_constructorTemplate;

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

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

  void InitIInkAnalysisNode(Local<Object> exports) {
    IInkAnalysisNode::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "createAnalyzer", CreateAnalyzer);
          




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



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

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

    private:

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


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

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

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


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

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::UI::Input::Inking::Analysis::InkAnalyzer^ result;
          result = wrapper->_instance->CreateAnalyzer();
          info.GetReturnValue().Set(WrapInkAnalyzer(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::Analysis::IInkAnalyzerFactory^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIInkAnalyzerFactory(::Windows::UI::Input::Inking::Analysis::IInkAnalyzerFactory^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::Analysis::IInkAnalyzerFactory^ UnwrapIInkAnalyzerFactory(Local<Value> value);
  };

  Persistent<FunctionTemplate> IInkAnalyzerFactory::s_constructorTemplate;

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

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

  void InitIInkAnalyzerFactory(Local<Object> exports) {
    IInkAnalyzerFactory::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getStrokeIds", GetStrokeIds);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("recognizedText").ToLocalChecked(), RecognizedTextGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("boundingRect").ToLocalChecked(), BoundingRectGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("children").ToLocalChecked(), ChildrenGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("id").ToLocalChecked(), IdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("parent").ToLocalChecked(), ParentGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("rotatedBoundingRect").ToLocalChecked(), RotatedBoundingRectGetter);

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



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

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

    private:

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


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

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

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


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

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<unsigned int>^ result;
          result = wrapper->_instance->GetStrokeIds();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned int>::CreateVectorViewWrapper(result, 
            [](unsigned int val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsUint32();
            },
            [](Local<Value> value) -> unsigned int {
              return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



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

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

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

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

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

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>^ result = wrapper->_instance->Children;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^ val) -> Local<Value> {
              return WrapIInkAnalysisNode(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^ {
              return UnwrapIInkAnalysisNode(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

      try  {
        ::Windows::UI::Input::Inking::Analysis::InkAnalysisNodeKind 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 ParentGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Foundation::Point>^ result = wrapper->_instance->RotatedBoundingRect;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Foundation::Point>::CreateVectorViewWrapper(result, 
            [](::Windows::Foundation::Point val) -> Local<Value> {
              return NodeRT::Utils::PointToJs(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsPoint(value);
            },
            [](Local<Value> value) -> ::Windows::Foundation::Point {
              return NodeRT::Utils::PointFromJs(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


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

      friend v8::Local<v8::Value> WrapInkAnalysisInkBullet(::Windows::UI::Input::Inking::Analysis::InkAnalysisInkBullet^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::Analysis::InkAnalysisInkBullet^ UnwrapInkAnalysisInkBullet(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkAnalysisInkBullet::s_constructorTemplate;

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

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

  void InitInkAnalysisInkBullet(Local<Object> exports) {
    InkAnalysisInkBullet::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getStrokeIds", GetStrokeIds);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("center").ToLocalChecked(), CenterGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("drawingKind").ToLocalChecked(), DrawingKindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("points").ToLocalChecked(), PointsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("boundingRect").ToLocalChecked(), BoundingRectGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("children").ToLocalChecked(), ChildrenGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("id").ToLocalChecked(), IdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("parent").ToLocalChecked(), ParentGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("rotatedBoundingRect").ToLocalChecked(), RotatedBoundingRectGetter);

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



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

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

    private:

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


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

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

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


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

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<unsigned int>^ result;
          result = wrapper->_instance->GetStrokeIds();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned int>::CreateVectorViewWrapper(result, 
            [](unsigned int val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsUint32();
            },
            [](Local<Value> value) -> unsigned int {
              return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



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

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

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

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

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

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

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Foundation::Point>^ result = wrapper->_instance->Points;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Foundation::Point>::CreateVectorViewWrapper(result, 
            [](::Windows::Foundation::Point val) -> Local<Value> {
              return NodeRT::Utils::PointToJs(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsPoint(value);
            },
            [](Local<Value> value) -> ::Windows::Foundation::Point {
              return NodeRT::Utils::PointFromJs(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BoundingRectGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>^ result = wrapper->_instance->Children;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^ val) -> Local<Value> {
              return WrapIInkAnalysisNode(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^ {
              return UnwrapIInkAnalysisNode(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

      try  {
        ::Windows::UI::Input::Inking::Analysis::InkAnalysisNodeKind 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 ParentGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Foundation::Point>^ result = wrapper->_instance->RotatedBoundingRect;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Foundation::Point>::CreateVectorViewWrapper(result, 
            [](::Windows::Foundation::Point val) -> Local<Value> {
              return NodeRT::Utils::PointToJs(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsPoint(value);
            },
            [](Local<Value> value) -> ::Windows::Foundation::Point {
              return NodeRT::Utils::PointFromJs(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


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

      friend v8::Local<v8::Value> WrapInkAnalysisInkDrawing(::Windows::UI::Input::Inking::Analysis::InkAnalysisInkDrawing^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::Analysis::InkAnalysisInkDrawing^ UnwrapInkAnalysisInkDrawing(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkAnalysisInkDrawing::s_constructorTemplate;

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

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

  void InitInkAnalysisInkDrawing(Local<Object> exports) {
    InkAnalysisInkDrawing::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getStrokeIds", GetStrokeIds);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("recognizedText").ToLocalChecked(), RecognizedTextGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("textAlternates").ToLocalChecked(), TextAlternatesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("boundingRect").ToLocalChecked(), BoundingRectGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("children").ToLocalChecked(), ChildrenGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("id").ToLocalChecked(), IdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("parent").ToLocalChecked(), ParentGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("rotatedBoundingRect").ToLocalChecked(), RotatedBoundingRectGetter);

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



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

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

    private:

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


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

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

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


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

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<unsigned int>^ result;
          result = wrapper->_instance->GetStrokeIds();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned int>::CreateVectorViewWrapper(result, 
            [](unsigned int val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsUint32();
            },
            [](Local<Value> value) -> unsigned int {
              return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



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

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

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

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Platform::String^>^ result = wrapper->_instance->TextAlternates;
        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;
      }
    }
      
    static void BoundingRectGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>^ result = wrapper->_instance->Children;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^ val) -> Local<Value> {
              return WrapIInkAnalysisNode(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^ {
              return UnwrapIInkAnalysisNode(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

      try  {
        ::Windows::UI::Input::Inking::Analysis::InkAnalysisNodeKind 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 ParentGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Foundation::Point>^ result = wrapper->_instance->RotatedBoundingRect;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Foundation::Point>::CreateVectorViewWrapper(result, 
            [](::Windows::Foundation::Point val) -> Local<Value> {
              return NodeRT::Utils::PointToJs(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsPoint(value);
            },
            [](Local<Value> value) -> ::Windows::Foundation::Point {
              return NodeRT::Utils::PointFromJs(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


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

      friend v8::Local<v8::Value> WrapInkAnalysisInkWord(::Windows::UI::Input::Inking::Analysis::InkAnalysisInkWord^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::Analysis::InkAnalysisInkWord^ UnwrapInkAnalysisInkWord(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkAnalysisInkWord::s_constructorTemplate;

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

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

  void InitInkAnalysisInkWord(Local<Object> exports) {
    InkAnalysisInkWord::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getStrokeIds", GetStrokeIds);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("indentLevel").ToLocalChecked(), IndentLevelGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("recognizedText").ToLocalChecked(), RecognizedTextGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("boundingRect").ToLocalChecked(), BoundingRectGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("children").ToLocalChecked(), ChildrenGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("id").ToLocalChecked(), IdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("parent").ToLocalChecked(), ParentGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("rotatedBoundingRect").ToLocalChecked(), RotatedBoundingRectGetter);

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



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

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

    private:

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


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

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

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


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

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<unsigned int>^ result;
          result = wrapper->_instance->GetStrokeIds();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned int>::CreateVectorViewWrapper(result, 
            [](unsigned int val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsUint32();
            },
            [](Local<Value> value) -> unsigned int {
              return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



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

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

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

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

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

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

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

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

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>^ result = wrapper->_instance->Children;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^ val) -> Local<Value> {
              return WrapIInkAnalysisNode(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^ {
              return UnwrapIInkAnalysisNode(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

      try  {
        ::Windows::UI::Input::Inking::Analysis::InkAnalysisNodeKind 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 ParentGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Foundation::Point>^ result = wrapper->_instance->RotatedBoundingRect;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Foundation::Point>::CreateVectorViewWrapper(result, 
            [](::Windows::Foundation::Point val) -> Local<Value> {
              return NodeRT::Utils::PointToJs(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsPoint(value);
            },
            [](Local<Value> value) -> ::Windows::Foundation::Point {
              return NodeRT::Utils::PointFromJs(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


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

      friend v8::Local<v8::Value> WrapInkAnalysisLine(::Windows::UI::Input::Inking::Analysis::InkAnalysisLine^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::Analysis::InkAnalysisLine^ UnwrapInkAnalysisLine(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkAnalysisLine::s_constructorTemplate;

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

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

  void InitInkAnalysisLine(Local<Object> exports) {
    InkAnalysisLine::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getStrokeIds", GetStrokeIds);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("recognizedText").ToLocalChecked(), RecognizedTextGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("boundingRect").ToLocalChecked(), BoundingRectGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("children").ToLocalChecked(), ChildrenGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("id").ToLocalChecked(), IdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("parent").ToLocalChecked(), ParentGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("rotatedBoundingRect").ToLocalChecked(), RotatedBoundingRectGetter);

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



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

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

    private:

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


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

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

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


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

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<unsigned int>^ result;
          result = wrapper->_instance->GetStrokeIds();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned int>::CreateVectorViewWrapper(result, 
            [](unsigned int val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsUint32();
            },
            [](Local<Value> value) -> unsigned int {
              return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



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

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

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

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

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

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>^ result = wrapper->_instance->Children;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^ val) -> Local<Value> {
              return WrapIInkAnalysisNode(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^ {
              return UnwrapIInkAnalysisNode(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

      try  {
        ::Windows::UI::Input::Inking::Analysis::InkAnalysisNodeKind 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 ParentGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Foundation::Point>^ result = wrapper->_instance->RotatedBoundingRect;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Foundation::Point>::CreateVectorViewWrapper(result, 
            [](::Windows::Foundation::Point val) -> Local<Value> {
              return NodeRT::Utils::PointToJs(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsPoint(value);
            },
            [](Local<Value> value) -> ::Windows::Foundation::Point {
              return NodeRT::Utils::PointFromJs(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


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

      friend v8::Local<v8::Value> WrapInkAnalysisListItem(::Windows::UI::Input::Inking::Analysis::InkAnalysisListItem^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::Analysis::InkAnalysisListItem^ UnwrapInkAnalysisListItem(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkAnalysisListItem::s_constructorTemplate;

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

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

  void InitInkAnalysisListItem(Local<Object> exports) {
    InkAnalysisListItem::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getStrokeIds", GetStrokeIds);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("boundingRect").ToLocalChecked(), BoundingRectGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("children").ToLocalChecked(), ChildrenGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("id").ToLocalChecked(), IdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("parent").ToLocalChecked(), ParentGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("rotatedBoundingRect").ToLocalChecked(), RotatedBoundingRectGetter);

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



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

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

    private:

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


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

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

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


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

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<unsigned int>^ result;
          result = wrapper->_instance->GetStrokeIds();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned int>::CreateVectorViewWrapper(result, 
            [](unsigned int val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsUint32();
            },
            [](Local<Value> value) -> unsigned int {
              return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
            }
          ));
          return;
        } catch (Platform::Exception ^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::Analysis::InkAnalysisNode^>(info.This())) {
        return;
      }

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>^ result = wrapper->_instance->Children;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^ val) -> Local<Value> {
              return WrapIInkAnalysisNode(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^ {
              return UnwrapIInkAnalysisNode(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

      try  {
        ::Windows::UI::Input::Inking::Analysis::InkAnalysisNodeKind 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 ParentGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Foundation::Point>^ result = wrapper->_instance->RotatedBoundingRect;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Foundation::Point>::CreateVectorViewWrapper(result, 
            [](::Windows::Foundation::Point val) -> Local<Value> {
              return NodeRT::Utils::PointToJs(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsPoint(value);
            },
            [](Local<Value> value) -> ::Windows::Foundation::Point {
              return NodeRT::Utils::PointFromJs(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


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

      friend v8::Local<v8::Value> WrapInkAnalysisNode(::Windows::UI::Input::Inking::Analysis::InkAnalysisNode^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::Analysis::InkAnalysisNode^ UnwrapInkAnalysisNode(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkAnalysisNode::s_constructorTemplate;

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

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

  void InitInkAnalysisNode(Local<Object> exports) {
    InkAnalysisNode::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getStrokeIds", GetStrokeIds);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("boundingRect").ToLocalChecked(), BoundingRectGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("children").ToLocalChecked(), ChildrenGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("id").ToLocalChecked(), IdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("parent").ToLocalChecked(), ParentGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("rotatedBoundingRect").ToLocalChecked(), RotatedBoundingRectGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("recognizedText").ToLocalChecked(), RecognizedTextGetter);

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



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

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

    private:

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


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

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

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


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

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<unsigned int>^ result;
          result = wrapper->_instance->GetStrokeIds();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned int>::CreateVectorViewWrapper(result, 
            [](unsigned int val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsUint32();
            },
            [](Local<Value> value) -> unsigned int {
              return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
            }
          ));
          return;
        } catch (Platform::Exception ^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::Analysis::InkAnalysisParagraph^>(info.This())) {
        return;
      }

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>^ result = wrapper->_instance->Children;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^ val) -> Local<Value> {
              return WrapIInkAnalysisNode(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^ {
              return UnwrapIInkAnalysisNode(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

      try  {
        ::Windows::UI::Input::Inking::Analysis::InkAnalysisNodeKind 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 ParentGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Foundation::Point>^ result = wrapper->_instance->RotatedBoundingRect;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Foundation::Point>::CreateVectorViewWrapper(result, 
            [](::Windows::Foundation::Point val) -> Local<Value> {
              return NodeRT::Utils::PointToJs(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsPoint(value);
            },
            [](Local<Value> value) -> ::Windows::Foundation::Point {
              return NodeRT::Utils::PointFromJs(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RecognizedTextGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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


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

      friend v8::Local<v8::Value> WrapInkAnalysisParagraph(::Windows::UI::Input::Inking::Analysis::InkAnalysisParagraph^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::Analysis::InkAnalysisParagraph^ UnwrapInkAnalysisParagraph(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkAnalysisParagraph::s_constructorTemplate;

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

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

  void InitInkAnalysisParagraph(Local<Object> exports) {
    InkAnalysisParagraph::Init(exports);
  }

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





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

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



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

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

    private:

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


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

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

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





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

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

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

      try  {
        ::Windows::UI::Input::Inking::Analysis::InkAnalysisStatus result = wrapper->_instance->Status;
        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::Analysis::InkAnalysisResult^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInkAnalysisResult(::Windows::UI::Input::Inking::Analysis::InkAnalysisResult^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::Analysis::InkAnalysisResult^ UnwrapInkAnalysisResult(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkAnalysisResult::s_constructorTemplate;

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

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

  void InitInkAnalysisResult(Local<Object> exports) {
    InkAnalysisResult::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "findNodes", FindNodes);
            Nan::SetPrototypeMethod(localRef, "getStrokeIds", GetStrokeIds);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("boundingRect").ToLocalChecked(), BoundingRectGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("children").ToLocalChecked(), ChildrenGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("id").ToLocalChecked(), IdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("parent").ToLocalChecked(), ParentGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("rotatedBoundingRect").ToLocalChecked(), RotatedBoundingRectGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("recognizedText").ToLocalChecked(), RecognizedTextGetter);

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



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

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

    private:

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


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

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

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


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

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

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

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::UI::Input::Inking::Analysis::InkAnalysisNodeKind arg0 = static_cast<::Windows::UI::Input::Inking::Analysis::InkAnalysisNodeKind>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>^ result;
          result = wrapper->_instance->FindNodes(arg0);
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^ val) -> Local<Value> {
              return WrapIInkAnalysisNode(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^ {
              return UnwrapIInkAnalysisNode(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 GetStrokeIds(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<unsigned int>^ result;
          result = wrapper->_instance->GetStrokeIds();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned int>::CreateVectorViewWrapper(result, 
            [](unsigned int val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsUint32();
            },
            [](Local<Value> value) -> unsigned int {
              return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
            }
          ));
          return;
        } catch (Platform::Exception ^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::Analysis::InkAnalysisRoot^>(info.This())) {
        return;
      }

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>^ result = wrapper->_instance->Children;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^ val) -> Local<Value> {
              return WrapIInkAnalysisNode(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^ {
              return UnwrapIInkAnalysisNode(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

      try  {
        ::Windows::UI::Input::Inking::Analysis::InkAnalysisNodeKind 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 ParentGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Foundation::Point>^ result = wrapper->_instance->RotatedBoundingRect;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Foundation::Point>::CreateVectorViewWrapper(result, 
            [](::Windows::Foundation::Point val) -> Local<Value> {
              return NodeRT::Utils::PointToJs(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsPoint(value);
            },
            [](Local<Value> value) -> ::Windows::Foundation::Point {
              return NodeRT::Utils::PointFromJs(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RecognizedTextGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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


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

      friend v8::Local<v8::Value> WrapInkAnalysisRoot(::Windows::UI::Input::Inking::Analysis::InkAnalysisRoot^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::Analysis::InkAnalysisRoot^ UnwrapInkAnalysisRoot(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkAnalysisRoot::s_constructorTemplate;

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

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

  void InitInkAnalysisRoot(Local<Object> exports) {
    InkAnalysisRoot::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getStrokeIds", GetStrokeIds);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("boundingRect").ToLocalChecked(), BoundingRectGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("children").ToLocalChecked(), ChildrenGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("id").ToLocalChecked(), IdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("parent").ToLocalChecked(), ParentGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("rotatedBoundingRect").ToLocalChecked(), RotatedBoundingRectGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("recognizedText").ToLocalChecked(), RecognizedTextGetter);

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



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

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

    private:

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


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

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

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


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

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<unsigned int>^ result;
          result = wrapper->_instance->GetStrokeIds();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned int>::CreateVectorViewWrapper(result, 
            [](unsigned int val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsUint32();
            },
            [](Local<Value> value) -> unsigned int {
              return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
            }
          ));
          return;
        } catch (Platform::Exception ^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::Analysis::InkAnalysisWritingRegion^>(info.This())) {
        return;
      }

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>^ result = wrapper->_instance->Children;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^ val) -> Local<Value> {
              return WrapIInkAnalysisNode(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Input::Inking::Analysis::IInkAnalysisNode^ {
              return UnwrapIInkAnalysisNode(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

      try  {
        ::Windows::UI::Input::Inking::Analysis::InkAnalysisNodeKind 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 ParentGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Foundation::Point>^ result = wrapper->_instance->RotatedBoundingRect;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Foundation::Point>::CreateVectorViewWrapper(result, 
            [](::Windows::Foundation::Point val) -> Local<Value> {
              return NodeRT::Utils::PointToJs(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsPoint(value);
            },
            [](Local<Value> value) -> ::Windows::Foundation::Point {
              return NodeRT::Utils::PointFromJs(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RecognizedTextGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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


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

      friend v8::Local<v8::Value> WrapInkAnalysisWritingRegion(::Windows::UI::Input::Inking::Analysis::InkAnalysisWritingRegion^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::Analysis::InkAnalysisWritingRegion^ UnwrapInkAnalysisWritingRegion(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkAnalysisWritingRegion::s_constructorTemplate;

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

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

  void InitInkAnalysisWritingRegion(Local<Object> exports) {
    InkAnalysisWritingRegion::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "addDataForStroke", AddDataForStroke);
            Nan::SetPrototypeMethod(localRef, "addDataForStrokes", AddDataForStrokes);
            Nan::SetPrototypeMethod(localRef, "clearDataForAllStrokes", ClearDataForAllStrokes);
            Nan::SetPrototypeMethod(localRef, "removeDataForStroke", RemoveDataForStroke);
            Nan::SetPrototypeMethod(localRef, "removeDataForStrokes", RemoveDataForStrokes);
            Nan::SetPrototypeMethod(localRef, "replaceDataForStroke", ReplaceDataForStroke);
            Nan::SetPrototypeMethod(localRef, "setStrokeDataKind", SetStrokeDataKind);
          

          
            Nan::SetPrototypeMethod(localRef, "analyzeAsync", AnalyzeAsync);
          


          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("analysisRoot").ToLocalChecked(), AnalysisRootGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isAnalyzing").ToLocalChecked(), IsAnalyzingGetter);

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



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

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

    private:

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


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Input::Inking::Analysis::InkAnalyzer^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::UI::Input::Inking::Analysis::InkAnalysisResult^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->AnalyzeAsync();
        }
        catch (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::UI::Input::Inking::Analysis::InkAnalysisResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapInkAnalysisResult(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 AddDataForStroke(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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

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

      InkAnalyzer *wrapper = InkAnalyzer::Unwrap<InkAnalyzer>(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 dynamic_cast<::Windows::UI::Input::Inking::InkStroke^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Windows::UI::Input::Inking::InkStroke^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          wrapper->_instance->AddDataForStrokes(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 ClearDataForAllStrokes(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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

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

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

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

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

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

      if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<unsigned int>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<unsigned int>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<unsigned int>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<unsigned int>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsUint32();
                 },
                 [](Local<Value> value) -> unsigned int {
                   return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<unsigned int>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          wrapper->_instance->RemoveDataForStrokes(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 ReplaceDataForStroke(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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

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

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

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



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

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

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

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

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

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

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


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

      friend v8::Local<v8::Value> WrapInkAnalyzer(::Windows::UI::Input::Inking::Analysis::InkAnalyzer^ wintRtInstance);
      friend ::Windows::UI::Input::Inking::Analysis::InkAnalyzer^ UnwrapInkAnalyzer(Local<Value> value);
  };

  Persistent<FunctionTemplate> InkAnalyzer::s_constructorTemplate;

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

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

  void InitInkAnalyzer(Local<Object> exports) {
    InkAnalyzer::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::Analysis::InitInkAnalysisDrawingKindEnum(target);
      NodeRT::Windows::UI::Input::Inking::Analysis::InitInkAnalysisNodeKindEnum(target);
      NodeRT::Windows::UI::Input::Inking::Analysis::InitInkAnalysisStatusEnum(target);
      NodeRT::Windows::UI::Input::Inking::Analysis::InitInkAnalysisStrokeKindEnum(target);
      NodeRT::Windows::UI::Input::Inking::Analysis::InitIInkAnalysisNode(target);
      NodeRT::Windows::UI::Input::Inking::Analysis::InitIInkAnalyzerFactory(target);
      NodeRT::Windows::UI::Input::Inking::Analysis::InitInkAnalysisInkBullet(target);
      NodeRT::Windows::UI::Input::Inking::Analysis::InitInkAnalysisInkDrawing(target);
      NodeRT::Windows::UI::Input::Inking::Analysis::InitInkAnalysisInkWord(target);
      NodeRT::Windows::UI::Input::Inking::Analysis::InitInkAnalysisLine(target);
      NodeRT::Windows::UI::Input::Inking::Analysis::InitInkAnalysisListItem(target);
      NodeRT::Windows::UI::Input::Inking::Analysis::InitInkAnalysisNode(target);
      NodeRT::Windows::UI::Input::Inking::Analysis::InitInkAnalysisParagraph(target);
      NodeRT::Windows::UI::Input::Inking::Analysis::InitInkAnalysisResult(target);
      NodeRT::Windows::UI::Input::Inking::Analysis::InitInkAnalysisRoot(target);
      NodeRT::Windows::UI::Input::Inking::Analysis::InitInkAnalysisWritingRegion(target);
      NodeRT::Windows::UI::Input::Inking::Analysis::InitInkAnalyzer(target);


  NodeRT::Utils::RegisterNameSpace("Windows.UI.Input.Inking.Analysis", target);
}



NODE_MODULE(binding, init)