// 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 Xaml { namespace Automation { namespace Provider { 
  v8::Local<v8::Value> WrapIAnnotationProvider(::Windows::UI::Xaml::Automation::Provider::IAnnotationProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::IAnnotationProvider^ UnwrapIAnnotationProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapIDockProvider(::Windows::UI::Xaml::Automation::Provider::IDockProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::IDockProvider^ UnwrapIDockProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapIDragProvider(::Windows::UI::Xaml::Automation::Provider::IDragProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::IDragProvider^ UnwrapIDragProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapIDropTargetProvider(::Windows::UI::Xaml::Automation::Provider::IDropTargetProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::IDropTargetProvider^ UnwrapIDropTargetProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapIExpandCollapseProvider(::Windows::UI::Xaml::Automation::Provider::IExpandCollapseProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::IExpandCollapseProvider^ UnwrapIExpandCollapseProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapIGridItemProvider(::Windows::UI::Xaml::Automation::Provider::IGridItemProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::IGridItemProvider^ UnwrapIGridItemProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapIGridProvider(::Windows::UI::Xaml::Automation::Provider::IGridProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::IGridProvider^ UnwrapIGridProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapIInvokeProvider(::Windows::UI::Xaml::Automation::Provider::IInvokeProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::IInvokeProvider^ UnwrapIInvokeProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapIItemContainerProvider(::Windows::UI::Xaml::Automation::Provider::IItemContainerProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::IItemContainerProvider^ UnwrapIItemContainerProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapIMultipleViewProvider(::Windows::UI::Xaml::Automation::Provider::IMultipleViewProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::IMultipleViewProvider^ UnwrapIMultipleViewProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapIObjectModelProvider(::Windows::UI::Xaml::Automation::Provider::IObjectModelProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::IObjectModelProvider^ UnwrapIObjectModelProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapIRangeValueProvider(::Windows::UI::Xaml::Automation::Provider::IRangeValueProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::IRangeValueProvider^ UnwrapIRangeValueProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapIScrollItemProvider(::Windows::UI::Xaml::Automation::Provider::IScrollItemProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::IScrollItemProvider^ UnwrapIScrollItemProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapIScrollProvider(::Windows::UI::Xaml::Automation::Provider::IScrollProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::IScrollProvider^ UnwrapIScrollProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapISelectionItemProvider(::Windows::UI::Xaml::Automation::Provider::ISelectionItemProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::ISelectionItemProvider^ UnwrapISelectionItemProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapISelectionProvider(::Windows::UI::Xaml::Automation::Provider::ISelectionProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::ISelectionProvider^ UnwrapISelectionProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapISpreadsheetItemProvider(::Windows::UI::Xaml::Automation::Provider::ISpreadsheetItemProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::ISpreadsheetItemProvider^ UnwrapISpreadsheetItemProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapISpreadsheetProvider(::Windows::UI::Xaml::Automation::Provider::ISpreadsheetProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::ISpreadsheetProvider^ UnwrapISpreadsheetProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapIStylesProvider(::Windows::UI::Xaml::Automation::Provider::IStylesProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::IStylesProvider^ UnwrapIStylesProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapISynchronizedInputProvider(::Windows::UI::Xaml::Automation::Provider::ISynchronizedInputProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::ISynchronizedInputProvider^ UnwrapISynchronizedInputProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapITableItemProvider(::Windows::UI::Xaml::Automation::Provider::ITableItemProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::ITableItemProvider^ UnwrapITableItemProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapITableProvider(::Windows::UI::Xaml::Automation::Provider::ITableProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::ITableProvider^ UnwrapITableProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapITextChildProvider(::Windows::UI::Xaml::Automation::Provider::ITextChildProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::ITextChildProvider^ UnwrapITextChildProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapITextRangeProvider(::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^ UnwrapITextRangeProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapITextProvider(::Windows::UI::Xaml::Automation::Provider::ITextProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::ITextProvider^ UnwrapITextProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapITextProvider2(::Windows::UI::Xaml::Automation::Provider::ITextProvider2^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::ITextProvider2^ UnwrapITextProvider2(Local<Value> value);
  
  v8::Local<v8::Value> WrapITextRangeProvider2(::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider2^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider2^ UnwrapITextRangeProvider2(Local<Value> value);
  
  v8::Local<v8::Value> WrapIToggleProvider(::Windows::UI::Xaml::Automation::Provider::IToggleProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::IToggleProvider^ UnwrapIToggleProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapITransformProvider(::Windows::UI::Xaml::Automation::Provider::ITransformProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::ITransformProvider^ UnwrapITransformProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapITransformProvider2(::Windows::UI::Xaml::Automation::Provider::ITransformProvider2^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::ITransformProvider2^ UnwrapITransformProvider2(Local<Value> value);
  
  v8::Local<v8::Value> WrapIValueProvider(::Windows::UI::Xaml::Automation::Provider::IValueProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::IValueProvider^ UnwrapIValueProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapIVirtualizedItemProvider(::Windows::UI::Xaml::Automation::Provider::IVirtualizedItemProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::IVirtualizedItemProvider^ UnwrapIVirtualizedItemProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapIWindowProvider(::Windows::UI::Xaml::Automation::Provider::IWindowProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::IWindowProvider^ UnwrapIWindowProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapIRawElementProviderSimple(::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ UnwrapIRawElementProviderSimple(Local<Value> value);
  
  v8::Local<v8::Value> WrapICustomNavigationProvider(::Windows::UI::Xaml::Automation::Provider::ICustomNavigationProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::ICustomNavigationProvider^ UnwrapICustomNavigationProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapITextEditProvider(::Windows::UI::Xaml::Automation::Provider::ITextEditProvider^ wintRtInstance);
  ::Windows::UI::Xaml::Automation::Provider::ITextEditProvider^ UnwrapITextEditProvider(Local<Value> value);
  




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

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

    return true;
  }

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

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

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

    return returnValue;
  }

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

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


    return scope.Escape(obj);
  }
  static bool 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 IAnnotationProvider : 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>("IAnnotationProvider").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("annotationTypeId").ToLocalChecked(), AnnotationTypeIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("annotationTypeName").ToLocalChecked(), AnnotationTypeNameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("author").ToLocalChecked(), AuthorGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dateTime").ToLocalChecked(), DateTimeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("target").ToLocalChecked(), TargetGetter);

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



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

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

    private:

      IAnnotationProvider(::Windows::UI::Xaml::Automation::Provider::IAnnotationProvider^ 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::Xaml::Automation::Provider::IAnnotationProvider^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IAnnotationProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IAnnotationProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IAnnotationProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IAnnotationProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IAnnotationProvider^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ result = wrapper->_instance->Target;
        info.GetReturnValue().Set(WrapIRawElementProviderSimple(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::Automation::Provider::IAnnotationProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIAnnotationProvider(::Windows::UI::Xaml::Automation::Provider::IAnnotationProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::IAnnotationProvider^ UnwrapIAnnotationProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> IAnnotationProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::IAnnotationProvider^ UnwrapIAnnotationProvider(Local<Value> value) {
     return IAnnotationProvider::Unwrap<IAnnotationProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIAnnotationProvider(Local<Object> exports) {
    IAnnotationProvider::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "setDockPosition", SetDockPosition);
          



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

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



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

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

    private:

      IDockProvider(::Windows::UI::Xaml::Automation::Provider::IDockProvider^ 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::Xaml::Automation::Provider::IDockProvider^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IDockProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IDockProvider^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::UI::Xaml::Automation::Provider::IDockProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIDockProvider(::Windows::UI::Xaml::Automation::Provider::IDockProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::IDockProvider^ UnwrapIDockProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> IDockProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::IDockProvider^ UnwrapIDockProvider(Local<Value> value) {
     return IDockProvider::Unwrap<IDockProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIDockProvider(Local<Object> exports) {
    IDockProvider::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getGrabbedItems", GetGrabbedItems);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dropEffect").ToLocalChecked(), DropEffectGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dropEffects").ToLocalChecked(), DropEffectsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isGrabbed").ToLocalChecked(), IsGrabbedGetter);

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



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

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

    private:

      IDragProvider(::Windows::UI::Xaml::Automation::Provider::IDragProvider^ 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::Xaml::Automation::Provider::IDragProvider^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IDragProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Platform::Array<::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^>^ result;
          result = wrapper->_instance->GetGrabbedItems();
          info.GetReturnValue().Set(NodeRT::Collections::ArrayWrapper<::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^>::CreateArrayWrapper(result, 
            [](::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ val) -> Local<Value> {
              return WrapIRawElementProviderSimple(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ {
              return UnwrapIRawElementProviderSimple(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 DropEffectGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IDragProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IDragProvider^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::Array<::Platform::String^>^ result = wrapper->_instance->DropEffects;
        info.GetReturnValue().Set(NodeRT::Collections::ArrayWrapper<::Platform::String^>::CreateArrayWrapper(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 IsGrabbedGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IDragProvider^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::UI::Xaml::Automation::Provider::IDragProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIDragProvider(::Windows::UI::Xaml::Automation::Provider::IDragProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::IDragProvider^ UnwrapIDragProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> IDragProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::IDragProvider^ UnwrapIDragProvider(Local<Value> value) {
     return IDragProvider::Unwrap<IDragProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIDragProvider(Local<Object> exports) {
    IDragProvider::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dropEffect").ToLocalChecked(), DropEffectGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dropEffects").ToLocalChecked(), DropEffectsGetter);

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



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

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

    private:

      IDropTargetProvider(::Windows::UI::Xaml::Automation::Provider::IDropTargetProvider^ 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::Xaml::Automation::Provider::IDropTargetProvider^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IDropTargetProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IDropTargetProvider^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::Array<::Platform::String^>^ result = wrapper->_instance->DropEffects;
        info.GetReturnValue().Set(NodeRT::Collections::ArrayWrapper<::Platform::String^>::CreateArrayWrapper(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;
      }
    }
      


    private:
      ::Windows::UI::Xaml::Automation::Provider::IDropTargetProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIDropTargetProvider(::Windows::UI::Xaml::Automation::Provider::IDropTargetProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::IDropTargetProvider^ UnwrapIDropTargetProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> IDropTargetProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::IDropTargetProvider^ UnwrapIDropTargetProvider(Local<Value> value) {
     return IDropTargetProvider::Unwrap<IDropTargetProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIDropTargetProvider(Local<Object> exports) {
    IDropTargetProvider::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "collapse", Collapse);
            Nan::SetPrototypeMethod(localRef, "expand", Expand);
          



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

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



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

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

    private:

      IExpandCollapseProvider(::Windows::UI::Xaml::Automation::Provider::IExpandCollapseProvider^ 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::Xaml::Automation::Provider::IExpandCollapseProvider^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IExpandCollapseProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IExpandCollapseProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IExpandCollapseProvider^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::UI::Xaml::Automation::Provider::IExpandCollapseProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIExpandCollapseProvider(::Windows::UI::Xaml::Automation::Provider::IExpandCollapseProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::IExpandCollapseProvider^ UnwrapIExpandCollapseProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> IExpandCollapseProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::IExpandCollapseProvider^ UnwrapIExpandCollapseProvider(Local<Value> value) {
     return IExpandCollapseProvider::Unwrap<IExpandCollapseProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIExpandCollapseProvider(Local<Object> exports) {
    IExpandCollapseProvider::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("column").ToLocalChecked(), ColumnGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("columnSpan").ToLocalChecked(), ColumnSpanGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("containingGrid").ToLocalChecked(), ContainingGridGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("row").ToLocalChecked(), RowGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("rowSpan").ToLocalChecked(), RowSpanGetter);

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



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

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

    private:

      IGridItemProvider(::Windows::UI::Xaml::Automation::Provider::IGridItemProvider^ 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::Xaml::Automation::Provider::IGridItemProvider^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IGridItemProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IGridItemProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IGridItemProvider^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ result = wrapper->_instance->ContainingGrid;
        info.GetReturnValue().Set(WrapIRawElementProviderSimple(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RowGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IGridItemProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IGridItemProvider^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::UI::Xaml::Automation::Provider::IGridItemProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIGridItemProvider(::Windows::UI::Xaml::Automation::Provider::IGridItemProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::IGridItemProvider^ UnwrapIGridItemProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> IGridItemProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::IGridItemProvider^ UnwrapIGridItemProvider(Local<Value> value) {
     return IGridItemProvider::Unwrap<IGridItemProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIGridItemProvider(Local<Object> exports) {
    IGridItemProvider::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getItem", GetItem);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("columnCount").ToLocalChecked(), ColumnCountGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("rowCount").ToLocalChecked(), RowCountGetter);

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



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

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

    private:

      IGridProvider(::Windows::UI::Xaml::Automation::Provider::IGridProvider^ 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::Xaml::Automation::Provider::IGridProvider^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IGridProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 2
        && info[0]->IsInt32()
        && info[1]->IsInt32())
      {
        try
        {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          int arg1 = static_cast<int>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          ::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ result;
          result = wrapper->_instance->GetItem(arg0, arg1);
          info.GetReturnValue().Set(WrapIRawElementProviderSimple(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IGridProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IGridProvider^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::UI::Xaml::Automation::Provider::IGridProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIGridProvider(::Windows::UI::Xaml::Automation::Provider::IGridProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::IGridProvider^ UnwrapIGridProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> IGridProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::IGridProvider^ UnwrapIGridProvider(Local<Value> value) {
     return IGridProvider::Unwrap<IGridProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIGridProvider(Local<Object> exports) {
    IGridProvider::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "invoke", Invoke);
          




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



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

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

    private:

      IInvokeProvider(::Windows::UI::Xaml::Automation::Provider::IInvokeProvider^ 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::Xaml::Automation::Provider::IInvokeProvider^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IInvokeProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->Invoke();
          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::Xaml::Automation::Provider::IInvokeProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIInvokeProvider(::Windows::UI::Xaml::Automation::Provider::IInvokeProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::IInvokeProvider^ UnwrapIInvokeProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> IInvokeProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::IInvokeProvider^ UnwrapIInvokeProvider(Local<Value> value) {
     return IInvokeProvider::Unwrap<IInvokeProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIInvokeProvider(Local<Object> exports) {
    IInvokeProvider::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "findItemByProperty", FindItemByProperty);
          




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



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

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

    private:

      IItemContainerProvider(::Windows::UI::Xaml::Automation::Provider::IItemContainerProvider^ 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::Xaml::Automation::Provider::IItemContainerProvider^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IItemContainerProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::AutomationProperty^>(info[1])
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[2]))
      {
        try
        {
          ::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ arg0 = UnwrapIRawElementProviderSimple(info[0]);
          ::Windows::UI::Xaml::Automation::AutomationProperty^ arg1 = dynamic_cast<::Windows::UI::Xaml::Automation::AutomationProperty^>(NodeRT::Utils::GetObjectInstance(info[1]));
          ::Platform::Object^ arg2 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[2]));
          
          ::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ result;
          result = wrapper->_instance->FindItemByProperty(arg0, arg1, arg2);
          info.GetReturnValue().Set(WrapIRawElementProviderSimple(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::Xaml::Automation::Provider::IItemContainerProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIItemContainerProvider(::Windows::UI::Xaml::Automation::Provider::IItemContainerProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::IItemContainerProvider^ UnwrapIItemContainerProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> IItemContainerProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::IItemContainerProvider^ UnwrapIItemContainerProvider(Local<Value> value) {
     return IItemContainerProvider::Unwrap<IItemContainerProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIItemContainerProvider(Local<Object> exports) {
    IItemContainerProvider::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getSupportedViews", GetSupportedViews);
            Nan::SetPrototypeMethod(localRef, "getViewName", GetViewName);
            Nan::SetPrototypeMethod(localRef, "setCurrentView", SetCurrentView);
          



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

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



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

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

    private:

      IMultipleViewProvider(::Windows::UI::Xaml::Automation::Provider::IMultipleViewProvider^ 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::Xaml::Automation::Provider::IMultipleViewProvider^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IMultipleViewProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Platform::Array<int>^ result;
          result = wrapper->_instance->GetSupportedViews();
          info.GetReturnValue().Set(NodeRT::Collections::ArrayWrapper<int>::CreateArrayWrapper(result, 
            [](int val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsInt32();
            },
            [](Local<Value> value) -> int {
              return static_cast<int>(Nan::To<int32_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 GetViewName(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IMultipleViewProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          Platform::String^ result;
          result = wrapper->_instance->GetViewName(arg0);
          info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
          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 SetCurrentView(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IMultipleViewProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IMultipleViewProvider^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::UI::Xaml::Automation::Provider::IMultipleViewProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIMultipleViewProvider(::Windows::UI::Xaml::Automation::Provider::IMultipleViewProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::IMultipleViewProvider^ UnwrapIMultipleViewProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> IMultipleViewProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::IMultipleViewProvider^ UnwrapIMultipleViewProvider(Local<Value> value) {
     return IMultipleViewProvider::Unwrap<IMultipleViewProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIMultipleViewProvider(Local<Object> exports) {
    IMultipleViewProvider::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getUnderlyingObjectModel", GetUnderlyingObjectModel);
          




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



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

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

    private:

      IObjectModelProvider(::Windows::UI::Xaml::Automation::Provider::IObjectModelProvider^ 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::Xaml::Automation::Provider::IObjectModelProvider^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IObjectModelProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Platform::Object^ result;
          result = wrapper->_instance->GetUnderlyingObjectModel();
          info.GetReturnValue().Set(CreateOpaqueWrapper(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





    private:
      ::Windows::UI::Xaml::Automation::Provider::IObjectModelProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIObjectModelProvider(::Windows::UI::Xaml::Automation::Provider::IObjectModelProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::IObjectModelProvider^ UnwrapIObjectModelProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> IObjectModelProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::IObjectModelProvider^ UnwrapIObjectModelProvider(Local<Value> value) {
     return IObjectModelProvider::Unwrap<IObjectModelProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIObjectModelProvider(Local<Object> exports) {
    IObjectModelProvider::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "setValue", SetValue);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isReadOnly").ToLocalChecked(), IsReadOnlyGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("largeChange").ToLocalChecked(), LargeChangeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maximum").ToLocalChecked(), MaximumGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("minimum").ToLocalChecked(), MinimumGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("smallChange").ToLocalChecked(), SmallChangeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("value").ToLocalChecked(), ValueGetter);

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



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

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

    private:

      IRangeValueProvider(::Windows::UI::Xaml::Automation::Provider::IRangeValueProvider^ 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::Xaml::Automation::Provider::IRangeValueProvider^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IRangeValueProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsNumber())
      {
        try
        {
          double arg0 = Nan::To<double>(info[0]).FromMaybe(0.0);
          
          wrapper->_instance->SetValue(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 IsReadOnlyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IRangeValueProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IRangeValueProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IRangeValueProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IRangeValueProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IRangeValueProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IRangeValueProvider^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::UI::Xaml::Automation::Provider::IRangeValueProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIRangeValueProvider(::Windows::UI::Xaml::Automation::Provider::IRangeValueProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::IRangeValueProvider^ UnwrapIRangeValueProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> IRangeValueProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::IRangeValueProvider^ UnwrapIRangeValueProvider(Local<Value> value) {
     return IRangeValueProvider::Unwrap<IRangeValueProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIRangeValueProvider(Local<Object> exports) {
    IRangeValueProvider::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "scrollIntoView", ScrollIntoView);
          




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



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

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

    private:

      IScrollItemProvider(::Windows::UI::Xaml::Automation::Provider::IScrollItemProvider^ 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::Xaml::Automation::Provider::IScrollItemProvider^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IScrollItemProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->ScrollIntoView();
          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::Xaml::Automation::Provider::IScrollItemProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIScrollItemProvider(::Windows::UI::Xaml::Automation::Provider::IScrollItemProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::IScrollItemProvider^ UnwrapIScrollItemProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> IScrollItemProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::IScrollItemProvider^ UnwrapIScrollItemProvider(Local<Value> value) {
     return IScrollItemProvider::Unwrap<IScrollItemProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIScrollItemProvider(Local<Object> exports) {
    IScrollItemProvider::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "scroll", Scroll);
            Nan::SetPrototypeMethod(localRef, "setScrollPercent", SetScrollPercent);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("horizontalScrollPercent").ToLocalChecked(), HorizontalScrollPercentGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("horizontalViewSize").ToLocalChecked(), HorizontalViewSizeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("horizontallyScrollable").ToLocalChecked(), HorizontallyScrollableGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("verticalScrollPercent").ToLocalChecked(), VerticalScrollPercentGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("verticalViewSize").ToLocalChecked(), VerticalViewSizeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("verticallyScrollable").ToLocalChecked(), VerticallyScrollableGetter);

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



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

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

    private:

      IScrollProvider(::Windows::UI::Xaml::Automation::Provider::IScrollProvider^ 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::Xaml::Automation::Provider::IScrollProvider^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IScrollProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 2
        && info[0]->IsInt32()
        && info[1]->IsInt32())
      {
        try
        {
          ::Windows::UI::Xaml::Automation::ScrollAmount arg0 = static_cast<::Windows::UI::Xaml::Automation::ScrollAmount>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          ::Windows::UI::Xaml::Automation::ScrollAmount arg1 = static_cast<::Windows::UI::Xaml::Automation::ScrollAmount>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          wrapper->_instance->Scroll(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 SetScrollPercent(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IScrollProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 2
        && info[0]->IsNumber()
        && info[1]->IsNumber())
      {
        try
        {
          double arg0 = Nan::To<double>(info[0]).FromMaybe(0.0);
          double arg1 = Nan::To<double>(info[1]).FromMaybe(0.0);
          
          wrapper->_instance->SetScrollPercent(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 HorizontalScrollPercentGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IScrollProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IScrollProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IScrollProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IScrollProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IScrollProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IScrollProvider^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::UI::Xaml::Automation::Provider::IScrollProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIScrollProvider(::Windows::UI::Xaml::Automation::Provider::IScrollProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::IScrollProvider^ UnwrapIScrollProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> IScrollProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::IScrollProvider^ UnwrapIScrollProvider(Local<Value> value) {
     return IScrollProvider::Unwrap<IScrollProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIScrollProvider(Local<Object> exports) {
    IScrollProvider::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "addToSelection", AddToSelection);
            Nan::SetPrototypeMethod(localRef, "removeFromSelection", RemoveFromSelection);
            Nan::SetPrototypeMethod(localRef, "select", Select);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isSelected").ToLocalChecked(), IsSelectedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("selectionContainer").ToLocalChecked(), SelectionContainerGetter);

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



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

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

    private:

      ISelectionItemProvider(::Windows::UI::Xaml::Automation::Provider::ISelectionItemProvider^ 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::Xaml::Automation::Provider::ISelectionItemProvider^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ISelectionItemProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ISelectionItemProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ISelectionItemProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ISelectionItemProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ISelectionItemProvider^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ result = wrapper->_instance->SelectionContainer;
        info.GetReturnValue().Set(WrapIRawElementProviderSimple(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::Automation::Provider::ISelectionItemProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapISelectionItemProvider(::Windows::UI::Xaml::Automation::Provider::ISelectionItemProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::ISelectionItemProvider^ UnwrapISelectionItemProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> ISelectionItemProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::ISelectionItemProvider^ UnwrapISelectionItemProvider(Local<Value> value) {
     return ISelectionItemProvider::Unwrap<ISelectionItemProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitISelectionItemProvider(Local<Object> exports) {
    ISelectionItemProvider::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getSelection", GetSelection);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("canSelectMultiple").ToLocalChecked(), CanSelectMultipleGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isSelectionRequired").ToLocalChecked(), IsSelectionRequiredGetter);

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



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

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

    private:

      ISelectionProvider(::Windows::UI::Xaml::Automation::Provider::ISelectionProvider^ 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::Xaml::Automation::Provider::ISelectionProvider^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ISelectionProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Platform::Array<::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^>^ result;
          result = wrapper->_instance->GetSelection();
          info.GetReturnValue().Set(NodeRT::Collections::ArrayWrapper<::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^>::CreateArrayWrapper(result, 
            [](::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ val) -> Local<Value> {
              return WrapIRawElementProviderSimple(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ {
              return UnwrapIRawElementProviderSimple(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 CanSelectMultipleGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ISelectionProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ISelectionProvider^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::UI::Xaml::Automation::Provider::ISelectionProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapISelectionProvider(::Windows::UI::Xaml::Automation::Provider::ISelectionProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::ISelectionProvider^ UnwrapISelectionProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> ISelectionProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::ISelectionProvider^ UnwrapISelectionProvider(Local<Value> value) {
     return ISelectionProvider::Unwrap<ISelectionProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitISelectionProvider(Local<Object> exports) {
    ISelectionProvider::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getAnnotationObjects", GetAnnotationObjects);
            Nan::SetPrototypeMethod(localRef, "getAnnotationTypes", GetAnnotationTypes);
          



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

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



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

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

    private:

      ISpreadsheetItemProvider(::Windows::UI::Xaml::Automation::Provider::ISpreadsheetItemProvider^ 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::Xaml::Automation::Provider::ISpreadsheetItemProvider^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ISpreadsheetItemProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Platform::Array<::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^>^ result;
          result = wrapper->_instance->GetAnnotationObjects();
          info.GetReturnValue().Set(NodeRT::Collections::ArrayWrapper<::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^>::CreateArrayWrapper(result, 
            [](::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ val) -> Local<Value> {
              return WrapIRawElementProviderSimple(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ {
              return UnwrapIRawElementProviderSimple(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 GetAnnotationTypes(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ISpreadsheetItemProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Platform::Array<::Windows::UI::Xaml::Automation::AnnotationType>^ result;
          result = wrapper->_instance->GetAnnotationTypes();
          info.GetReturnValue().Set(NodeRT::Collections::ArrayWrapper<::Windows::UI::Xaml::Automation::AnnotationType>::CreateArrayWrapper(result, 
            [](::Windows::UI::Xaml::Automation::AnnotationType val) -> Local<Value> {
              return Nan::New<Integer>(static_cast<int>(val));
            },
            [](Local<Value> value) -> bool {
              return value->IsInt32();
            },
            [](Local<Value> value) -> ::Windows::UI::Xaml::Automation::AnnotationType {
              return static_cast<::Windows::UI::Xaml::Automation::AnnotationType>(Nan::To<int32_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 FormulaGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ISpreadsheetItemProvider^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::UI::Xaml::Automation::Provider::ISpreadsheetItemProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapISpreadsheetItemProvider(::Windows::UI::Xaml::Automation::Provider::ISpreadsheetItemProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::ISpreadsheetItemProvider^ UnwrapISpreadsheetItemProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> ISpreadsheetItemProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::ISpreadsheetItemProvider^ UnwrapISpreadsheetItemProvider(Local<Value> value) {
     return ISpreadsheetItemProvider::Unwrap<ISpreadsheetItemProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitISpreadsheetItemProvider(Local<Object> exports) {
    ISpreadsheetItemProvider::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getItemByName", GetItemByName);
          




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



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

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

    private:

      ISpreadsheetProvider(::Windows::UI::Xaml::Automation::Provider::ISpreadsheetProvider^ 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::Xaml::Automation::Provider::ISpreadsheetProvider^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ISpreadsheetProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          ::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ result;
          result = wrapper->_instance->GetItemByName(arg0);
          info.GetReturnValue().Set(WrapIRawElementProviderSimple(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::Xaml::Automation::Provider::ISpreadsheetProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapISpreadsheetProvider(::Windows::UI::Xaml::Automation::Provider::ISpreadsheetProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::ISpreadsheetProvider^ UnwrapISpreadsheetProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> ISpreadsheetProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::ISpreadsheetProvider^ UnwrapISpreadsheetProvider(Local<Value> value) {
     return ISpreadsheetProvider::Unwrap<ISpreadsheetProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitISpreadsheetProvider(Local<Object> exports) {
    ISpreadsheetProvider::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("extendedProperties").ToLocalChecked(), ExtendedPropertiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("fillColor").ToLocalChecked(), FillColorGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("fillPatternColor").ToLocalChecked(), FillPatternColorGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("fillPatternStyle").ToLocalChecked(), FillPatternStyleGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("shape").ToLocalChecked(), ShapeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("styleId").ToLocalChecked(), StyleIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("styleName").ToLocalChecked(), StyleNameGetter);

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



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

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

    private:

      IStylesProvider(::Windows::UI::Xaml::Automation::Provider::IStylesProvider^ 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::Xaml::Automation::Provider::IStylesProvider^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IStylesProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IStylesProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IStylesProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IStylesProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IStylesProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IStylesProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IStylesProvider^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::UI::Xaml::Automation::Provider::IStylesProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIStylesProvider(::Windows::UI::Xaml::Automation::Provider::IStylesProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::IStylesProvider^ UnwrapIStylesProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> IStylesProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::IStylesProvider^ UnwrapIStylesProvider(Local<Value> value) {
     return IStylesProvider::Unwrap<IStylesProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIStylesProvider(Local<Object> exports) {
    IStylesProvider::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "cancel", Cancel);
            Nan::SetPrototypeMethod(localRef, "startListening", StartListening);
          




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



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

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

    private:

      ISynchronizedInputProvider(::Windows::UI::Xaml::Automation::Provider::ISynchronizedInputProvider^ 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::Xaml::Automation::Provider::ISynchronizedInputProvider^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ISynchronizedInputProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ISynchronizedInputProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::UI::Xaml::Automation::SynchronizedInputType arg0 = static_cast<::Windows::UI::Xaml::Automation::SynchronizedInputType>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          wrapper->_instance->StartListening(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;
      }
    }





    private:
      ::Windows::UI::Xaml::Automation::Provider::ISynchronizedInputProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapISynchronizedInputProvider(::Windows::UI::Xaml::Automation::Provider::ISynchronizedInputProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::ISynchronizedInputProvider^ UnwrapISynchronizedInputProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> ISynchronizedInputProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::ISynchronizedInputProvider^ UnwrapISynchronizedInputProvider(Local<Value> value) {
     return ISynchronizedInputProvider::Unwrap<ISynchronizedInputProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitISynchronizedInputProvider(Local<Object> exports) {
    ISynchronizedInputProvider::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getColumnHeaderItems", GetColumnHeaderItems);
            Nan::SetPrototypeMethod(localRef, "getRowHeaderItems", GetRowHeaderItems);
          




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



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

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

    private:

      ITableItemProvider(::Windows::UI::Xaml::Automation::Provider::ITableItemProvider^ 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::Xaml::Automation::Provider::ITableItemProvider^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITableItemProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Platform::Array<::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^>^ result;
          result = wrapper->_instance->GetColumnHeaderItems();
          info.GetReturnValue().Set(NodeRT::Collections::ArrayWrapper<::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^>::CreateArrayWrapper(result, 
            [](::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ val) -> Local<Value> {
              return WrapIRawElementProviderSimple(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ {
              return UnwrapIRawElementProviderSimple(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 GetRowHeaderItems(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITableItemProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Platform::Array<::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^>^ result;
          result = wrapper->_instance->GetRowHeaderItems();
          info.GetReturnValue().Set(NodeRT::Collections::ArrayWrapper<::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^>::CreateArrayWrapper(result, 
            [](::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ val) -> Local<Value> {
              return WrapIRawElementProviderSimple(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ {
              return UnwrapIRawElementProviderSimple(value);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





    private:
      ::Windows::UI::Xaml::Automation::Provider::ITableItemProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapITableItemProvider(::Windows::UI::Xaml::Automation::Provider::ITableItemProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::ITableItemProvider^ UnwrapITableItemProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> ITableItemProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::ITableItemProvider^ UnwrapITableItemProvider(Local<Value> value) {
     return ITableItemProvider::Unwrap<ITableItemProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitITableItemProvider(Local<Object> exports) {
    ITableItemProvider::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getColumnHeaders", GetColumnHeaders);
            Nan::SetPrototypeMethod(localRef, "getRowHeaders", GetRowHeaders);
          



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

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



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

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

    private:

      ITableProvider(::Windows::UI::Xaml::Automation::Provider::ITableProvider^ 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::Xaml::Automation::Provider::ITableProvider^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITableProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Platform::Array<::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^>^ result;
          result = wrapper->_instance->GetColumnHeaders();
          info.GetReturnValue().Set(NodeRT::Collections::ArrayWrapper<::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^>::CreateArrayWrapper(result, 
            [](::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ val) -> Local<Value> {
              return WrapIRawElementProviderSimple(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ {
              return UnwrapIRawElementProviderSimple(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 GetRowHeaders(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITableProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Platform::Array<::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^>^ result;
          result = wrapper->_instance->GetRowHeaders();
          info.GetReturnValue().Set(NodeRT::Collections::ArrayWrapper<::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^>::CreateArrayWrapper(result, 
            [](::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ val) -> Local<Value> {
              return WrapIRawElementProviderSimple(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ {
              return UnwrapIRawElementProviderSimple(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 RowOrColumnMajorGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITableProvider^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::UI::Xaml::Automation::Provider::ITableProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapITableProvider(::Windows::UI::Xaml::Automation::Provider::ITableProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::ITableProvider^ UnwrapITableProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> ITableProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::ITableProvider^ UnwrapITableProvider(Local<Value> value) {
     return ITableProvider::Unwrap<ITableProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitITableProvider(Local<Object> exports) {
    ITableProvider::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("textContainer").ToLocalChecked(), TextContainerGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("textRange").ToLocalChecked(), TextRangeGetter);

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



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

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

    private:

      ITextChildProvider(::Windows::UI::Xaml::Automation::Provider::ITextChildProvider^ 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::Xaml::Automation::Provider::ITextChildProvider^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextChildProvider^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ result = wrapper->_instance->TextContainer;
        info.GetReturnValue().Set(WrapIRawElementProviderSimple(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TextRangeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextChildProvider^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^ result = wrapper->_instance->TextRange;
        info.GetReturnValue().Set(WrapITextRangeProvider(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::Xaml::Automation::Provider::ITextChildProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapITextChildProvider(::Windows::UI::Xaml::Automation::Provider::ITextChildProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::ITextChildProvider^ UnwrapITextChildProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> ITextChildProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::ITextChildProvider^ UnwrapITextChildProvider(Local<Value> value) {
     return ITextChildProvider::Unwrap<ITextChildProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitITextChildProvider(Local<Object> exports) {
    ITextChildProvider::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "clone", Clone);
            Nan::SetPrototypeMethod(localRef, "compare", Compare);
            Nan::SetPrototypeMethod(localRef, "compareEndpoints", CompareEndpoints);
            Nan::SetPrototypeMethod(localRef, "expandToEnclosingUnit", ExpandToEnclosingUnit);
            Nan::SetPrototypeMethod(localRef, "findAttribute", FindAttribute);
            Nan::SetPrototypeMethod(localRef, "findText", FindText);
            Nan::SetPrototypeMethod(localRef, "getAttributeValue", GetAttributeValue);
            Nan::SetPrototypeMethod(localRef, "getBoundingRectangles", GetBoundingRectangles);
            Nan::SetPrototypeMethod(localRef, "getEnclosingElement", GetEnclosingElement);
            Nan::SetPrototypeMethod(localRef, "getText", GetText);
            Nan::SetPrototypeMethod(localRef, "move", Move);
            Nan::SetPrototypeMethod(localRef, "moveEndpointByUnit", MoveEndpointByUnit);
            Nan::SetPrototypeMethod(localRef, "moveEndpointByRange", MoveEndpointByRange);
            Nan::SetPrototypeMethod(localRef, "select", Select);
            Nan::SetPrototypeMethod(localRef, "addToSelection", AddToSelection);
            Nan::SetPrototypeMethod(localRef, "removeFromSelection", RemoveFromSelection);
            Nan::SetPrototypeMethod(localRef, "scrollIntoView", ScrollIntoView);
            Nan::SetPrototypeMethod(localRef, "getChildren", GetChildren);
          




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



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

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

    private:

      ITextRangeProvider(::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^ 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::Xaml::Automation::Provider::ITextRangeProvider^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^ result;
          result = wrapper->_instance->Clone();
          info.GetReturnValue().Set(WrapITextRangeProvider(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Compare(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^ arg0 = UnwrapITextRangeProvider(info[0]);
          
          bool result;
          result = wrapper->_instance->Compare(arg0);
          info.GetReturnValue().Set(Nan::New<Boolean>(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void CompareEndpoints(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 3
        && info[0]->IsInt32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^>(info[1])
        && info[2]->IsInt32())
      {
        try
        {
          ::Windows::UI::Xaml::Automation::Text::TextPatternRangeEndpoint arg0 = static_cast<::Windows::UI::Xaml::Automation::Text::TextPatternRangeEndpoint>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          ::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^ arg1 = UnwrapITextRangeProvider(info[1]);
          ::Windows::UI::Xaml::Automation::Text::TextPatternRangeEndpoint arg2 = static_cast<::Windows::UI::Xaml::Automation::Text::TextPatternRangeEndpoint>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          
          int result;
          result = wrapper->_instance->CompareEndpoints(arg0, arg1, arg2);
          info.GetReturnValue().Set(Nan::New<Integer>(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void ExpandToEnclosingUnit(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::UI::Xaml::Automation::Text::TextUnit arg0 = static_cast<::Windows::UI::Xaml::Automation::Text::TextUnit>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          wrapper->_instance->ExpandToEnclosingUnit(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 FindAttribute(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 3
        && info[0]->IsInt32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[1])
        && info[2]->IsBoolean())
      {
        try
        {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          ::Platform::Object^ arg1 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[1]));
          bool arg2 = Nan::To<bool>(info[2]).FromMaybe(false);
          
          ::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^ result;
          result = wrapper->_instance->FindAttribute(arg0, arg1, arg2);
          info.GetReturnValue().Set(WrapITextRangeProvider(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void FindText(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 3
        && info[0]->IsString()
        && info[1]->IsBoolean()
        && info[2]->IsBoolean())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          bool arg1 = Nan::To<bool>(info[1]).FromMaybe(false);
          bool arg2 = Nan::To<bool>(info[2]).FromMaybe(false);
          
          ::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^ result;
          result = wrapper->_instance->FindText(arg0, arg1, arg2);
          info.GetReturnValue().Set(WrapITextRangeProvider(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetAttributeValue(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          ::Platform::Object^ result;
          result = wrapper->_instance->GetAttributeValue(arg0);
          info.GetReturnValue().Set(CreateOpaqueWrapper(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetBoundingRectangles(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Platform::Array<double>^ arg0;
          
          wrapper->_instance->GetBoundingRectangles(&arg0);
          Local<Object> resObj = Nan::New<Object>();
          Nan::Set(resObj, Nan::New<String>("returnValue").ToLocalChecked(), NodeRT::Collections::ArrayWrapper<double>::CreateArrayWrapper(arg0, 
            [](double val) -> Local<Value> {
              return Nan::New<Number>(static_cast<double>(val));
            },
            [](Local<Value> value) -> bool {
              return value->IsNumber();
            },
            [](Local<Value> value) -> double {
              return Nan::To<double>(value).FromMaybe(0.0);
            }
          ));
          info.GetReturnValue().Set(resObj);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetEnclosingElement(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ result;
          result = wrapper->_instance->GetEnclosingElement();
          info.GetReturnValue().Set(WrapIRawElementProviderSimple(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetText(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          Platform::String^ result;
          result = wrapper->_instance->GetText(arg0);
          info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
          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 Move(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 3
        && info[0]->IsInt32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^>(info[1])
        && info[2]->IsInt32())
      {
        try
        {
          ::Windows::UI::Xaml::Automation::Text::TextPatternRangeEndpoint arg0 = static_cast<::Windows::UI::Xaml::Automation::Text::TextPatternRangeEndpoint>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          ::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^ arg1 = UnwrapITextRangeProvider(info[1]);
          ::Windows::UI::Xaml::Automation::Text::TextPatternRangeEndpoint arg2 = static_cast<::Windows::UI::Xaml::Automation::Text::TextPatternRangeEndpoint>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          
          wrapper->_instance->MoveEndpointByRange(arg0, arg1, arg2);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Select(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsBoolean())
      {
        try
        {
          bool arg0 = Nan::To<bool>(info[0]).FromMaybe(false);
          
          wrapper->_instance->ScrollIntoView(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 GetChildren(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Platform::Array<::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^>^ result;
          result = wrapper->_instance->GetChildren();
          info.GetReturnValue().Set(NodeRT::Collections::ArrayWrapper<::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^>::CreateArrayWrapper(result, 
            [](::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ val) -> Local<Value> {
              return WrapIRawElementProviderSimple(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ {
              return UnwrapIRawElementProviderSimple(value);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





    private:
      ::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapITextRangeProvider(::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^ UnwrapITextRangeProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> ITextRangeProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^ UnwrapITextRangeProvider(Local<Value> value) {
     return ITextRangeProvider::Unwrap<ITextRangeProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitITextRangeProvider(Local<Object> exports) {
    ITextRangeProvider::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getSelection", GetSelection);
            Nan::SetPrototypeMethod(localRef, "getVisibleRanges", GetVisibleRanges);
            Nan::SetPrototypeMethod(localRef, "rangeFromChild", RangeFromChild);
            Nan::SetPrototypeMethod(localRef, "rangeFromPoint", RangeFromPoint);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("documentRange").ToLocalChecked(), DocumentRangeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("supportedTextSelection").ToLocalChecked(), SupportedTextSelectionGetter);

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



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

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

    private:

      ITextProvider(::Windows::UI::Xaml::Automation::Provider::ITextProvider^ 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::Xaml::Automation::Provider::ITextProvider^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Platform::Array<::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^>^ result;
          result = wrapper->_instance->GetSelection();
          info.GetReturnValue().Set(NodeRT::Collections::ArrayWrapper<::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^>::CreateArrayWrapper(result, 
            [](::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^ val) -> Local<Value> {
              return WrapITextRangeProvider(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^ {
              return UnwrapITextRangeProvider(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 GetVisibleRanges(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Platform::Array<::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^>^ result;
          result = wrapper->_instance->GetVisibleRanges();
          info.GetReturnValue().Set(NodeRT::Collections::ArrayWrapper<::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^>::CreateArrayWrapper(result, 
            [](::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^ val) -> Local<Value> {
              return WrapITextRangeProvider(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^ {
              return UnwrapITextRangeProvider(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 RangeFromChild(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ arg0 = UnwrapIRawElementProviderSimple(info[0]);
          
          ::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^ result;
          result = wrapper->_instance->RangeFromChild(arg0);
          info.GetReturnValue().Set(WrapITextRangeProvider(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void RangeFromPoint(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && NodeRT::Utils::IsPoint(info[0]))
      {
        try
        {
          ::Windows::Foundation::Point arg0 = NodeRT::Utils::PointFromJs(info[0]);
          
          ::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^ result;
          result = wrapper->_instance->RangeFromPoint(arg0);
          info.GetReturnValue().Set(WrapITextRangeProvider(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextProvider^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^ result = wrapper->_instance->DocumentRange;
        info.GetReturnValue().Set(WrapITextRangeProvider(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SupportedTextSelectionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextProvider^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::UI::Xaml::Automation::Provider::ITextProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapITextProvider(::Windows::UI::Xaml::Automation::Provider::ITextProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::ITextProvider^ UnwrapITextProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> ITextProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::ITextProvider^ UnwrapITextProvider(Local<Value> value) {
     return ITextProvider::Unwrap<ITextProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitITextProvider(Local<Object> exports) {
    ITextProvider::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "rangeFromAnnotation", RangeFromAnnotation);
            Nan::SetPrototypeMethod(localRef, "getCaretRange", GetCaretRange);
          




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



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

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

    private:

      ITextProvider2(::Windows::UI::Xaml::Automation::Provider::ITextProvider2^ 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::Xaml::Automation::Provider::ITextProvider2^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextProvider2^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^>(info[0]))
      {
        try
        {
          ::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ arg0 = UnwrapIRawElementProviderSimple(info[0]);
          
          ::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^ result;
          result = wrapper->_instance->RangeFromAnnotation(arg0);
          info.GetReturnValue().Set(WrapITextRangeProvider(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetCaretRange(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextProvider2^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          bool arg0;
          
          ::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^ result;
          result = wrapper->_instance->GetCaretRange(&arg0);
          Local<Object> resObj = Nan::New<Object>();
          Nan::Set(resObj, Nan::New<String>("iTextRangeProvider").ToLocalChecked(), WrapITextRangeProvider(result));
          Nan::Set(resObj, Nan::New<String>("isActive").ToLocalChecked(), Nan::New<Boolean>(arg0));
          info.GetReturnValue().Set(resObj);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





    private:
      ::Windows::UI::Xaml::Automation::Provider::ITextProvider2^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapITextProvider2(::Windows::UI::Xaml::Automation::Provider::ITextProvider2^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::ITextProvider2^ UnwrapITextProvider2(Local<Value> value);
  };

  Persistent<FunctionTemplate> ITextProvider2::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::ITextProvider2^ UnwrapITextProvider2(Local<Value> value) {
     return ITextProvider2::Unwrap<ITextProvider2>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitITextProvider2(Local<Object> exports) {
    ITextProvider2::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "showContextMenu", ShowContextMenu);
          




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



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

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

    private:

      ITextRangeProvider2(::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider2^ 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::Xaml::Automation::Provider::ITextRangeProvider2^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider2^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->ShowContextMenu();
          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::Xaml::Automation::Provider::ITextRangeProvider2^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapITextRangeProvider2(::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider2^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider2^ UnwrapITextRangeProvider2(Local<Value> value);
  };

  Persistent<FunctionTemplate> ITextRangeProvider2::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider2^ UnwrapITextRangeProvider2(Local<Value> value) {
     return ITextRangeProvider2::Unwrap<ITextRangeProvider2>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitITextRangeProvider2(Local<Object> exports) {
    ITextRangeProvider2::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "toggle", Toggle);
          



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

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



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

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

    private:

      IToggleProvider(::Windows::UI::Xaml::Automation::Provider::IToggleProvider^ 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::Xaml::Automation::Provider::IToggleProvider^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IToggleProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IToggleProvider^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::UI::Xaml::Automation::Provider::IToggleProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIToggleProvider(::Windows::UI::Xaml::Automation::Provider::IToggleProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::IToggleProvider^ UnwrapIToggleProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> IToggleProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::IToggleProvider^ UnwrapIToggleProvider(Local<Value> value) {
     return IToggleProvider::Unwrap<IToggleProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIToggleProvider(Local<Object> exports) {
    IToggleProvider::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "move", Move);
            Nan::SetPrototypeMethod(localRef, "resize", Resize);
            Nan::SetPrototypeMethod(localRef, "rotate", Rotate);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("canMove").ToLocalChecked(), CanMoveGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("canResize").ToLocalChecked(), CanResizeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("canRotate").ToLocalChecked(), CanRotateGetter);

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



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

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

    private:

      ITransformProvider(::Windows::UI::Xaml::Automation::Provider::ITransformProvider^ 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::Xaml::Automation::Provider::ITransformProvider^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITransformProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 2
        && info[0]->IsNumber()
        && info[1]->IsNumber())
      {
        try
        {
          double arg0 = Nan::To<double>(info[0]).FromMaybe(0.0);
          double arg1 = Nan::To<double>(info[1]).FromMaybe(0.0);
          
          wrapper->_instance->Move(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 Resize(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITransformProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 2
        && info[0]->IsNumber()
        && info[1]->IsNumber())
      {
        try
        {
          double arg0 = Nan::To<double>(info[0]).FromMaybe(0.0);
          double arg1 = Nan::To<double>(info[1]).FromMaybe(0.0);
          
          wrapper->_instance->Resize(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 Rotate(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITransformProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsNumber())
      {
        try
        {
          double arg0 = Nan::To<double>(info[0]).FromMaybe(0.0);
          
          wrapper->_instance->Rotate(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 CanMoveGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITransformProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITransformProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITransformProvider^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::UI::Xaml::Automation::Provider::ITransformProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapITransformProvider(::Windows::UI::Xaml::Automation::Provider::ITransformProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::ITransformProvider^ UnwrapITransformProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> ITransformProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::ITransformProvider^ UnwrapITransformProvider(Local<Value> value) {
     return ITransformProvider::Unwrap<ITransformProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitITransformProvider(Local<Object> exports) {
    ITransformProvider::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "zoom", Zoom);
            Nan::SetPrototypeMethod(localRef, "zoomByUnit", ZoomByUnit);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("canZoom").ToLocalChecked(), CanZoomGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxZoom").ToLocalChecked(), MaxZoomGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("minZoom").ToLocalChecked(), MinZoomGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("zoomLevel").ToLocalChecked(), ZoomLevelGetter);

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



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

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

    private:

      ITransformProvider2(::Windows::UI::Xaml::Automation::Provider::ITransformProvider2^ 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::Xaml::Automation::Provider::ITransformProvider2^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITransformProvider2^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsNumber())
      {
        try
        {
          double arg0 = Nan::To<double>(info[0]).FromMaybe(0.0);
          
          wrapper->_instance->Zoom(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 ZoomByUnit(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITransformProvider2^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITransformProvider2^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITransformProvider2^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITransformProvider2^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITransformProvider2^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::UI::Xaml::Automation::Provider::ITransformProvider2^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapITransformProvider2(::Windows::UI::Xaml::Automation::Provider::ITransformProvider2^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::ITransformProvider2^ UnwrapITransformProvider2(Local<Value> value);
  };

  Persistent<FunctionTemplate> ITransformProvider2::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::ITransformProvider2^ UnwrapITransformProvider2(Local<Value> value) {
     return ITransformProvider2::Unwrap<ITransformProvider2>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitITransformProvider2(Local<Object> exports) {
    ITransformProvider2::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "setValue", SetValue);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isReadOnly").ToLocalChecked(), IsReadOnlyGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("value").ToLocalChecked(), ValueGetter);

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



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

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

    private:

      IValueProvider(::Windows::UI::Xaml::Automation::Provider::IValueProvider^ 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::Xaml::Automation::Provider::IValueProvider^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IValueProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          wrapper->_instance->SetValue(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 IsReadOnlyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IValueProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IValueProvider^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::UI::Xaml::Automation::Provider::IValueProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIValueProvider(::Windows::UI::Xaml::Automation::Provider::IValueProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::IValueProvider^ UnwrapIValueProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> IValueProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::IValueProvider^ UnwrapIValueProvider(Local<Value> value) {
     return IValueProvider::Unwrap<IValueProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIValueProvider(Local<Object> exports) {
    IValueProvider::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "realize", Realize);
          




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



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

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

    private:

      IVirtualizedItemProvider(::Windows::UI::Xaml::Automation::Provider::IVirtualizedItemProvider^ 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::Xaml::Automation::Provider::IVirtualizedItemProvider^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IVirtualizedItemProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->Realize();
          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::Xaml::Automation::Provider::IVirtualizedItemProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIVirtualizedItemProvider(::Windows::UI::Xaml::Automation::Provider::IVirtualizedItemProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::IVirtualizedItemProvider^ UnwrapIVirtualizedItemProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> IVirtualizedItemProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::IVirtualizedItemProvider^ UnwrapIVirtualizedItemProvider(Local<Value> value) {
     return IVirtualizedItemProvider::Unwrap<IVirtualizedItemProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIVirtualizedItemProvider(Local<Object> exports) {
    IVirtualizedItemProvider::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "close", Close);
            Nan::SetPrototypeMethod(localRef, "setVisualState", SetVisualState);
            Nan::SetPrototypeMethod(localRef, "waitForInputIdle", WaitForInputIdle);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("interactionState").ToLocalChecked(), InteractionStateGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isModal").ToLocalChecked(), IsModalGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isTopmost").ToLocalChecked(), IsTopmostGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maximizable").ToLocalChecked(), MaximizableGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("minimizable").ToLocalChecked(), MinimizableGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("visualState").ToLocalChecked(), VisualStateGetter);

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



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

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

    private:

      IWindowProvider(::Windows::UI::Xaml::Automation::Provider::IWindowProvider^ 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::Xaml::Automation::Provider::IWindowProvider^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IWindowProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IWindowProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::UI::Xaml::Automation::WindowVisualState arg0 = static_cast<::Windows::UI::Xaml::Automation::WindowVisualState>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          wrapper->_instance->SetVisualState(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 WaitForInputIdle(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IWindowProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          bool result;
          result = wrapper->_instance->WaitForInputIdle(arg0);
          info.GetReturnValue().Set(Nan::New<Boolean>(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IWindowProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IWindowProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IWindowProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IWindowProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IWindowProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::IWindowProvider^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::UI::Xaml::Automation::Provider::IWindowProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIWindowProvider(::Windows::UI::Xaml::Automation::Provider::IWindowProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::IWindowProvider^ UnwrapIWindowProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> IWindowProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::IWindowProvider^ UnwrapIWindowProvider(Local<Value> value) {
     return IWindowProvider::Unwrap<IWindowProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIWindowProvider(Local<Object> exports) {
    IWindowProvider::Init(exports);
  }

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





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

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



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

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

    private:

      IRawElementProviderSimple(::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ 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::Xaml::Automation::Provider::IRawElementProviderSimple^ winRtInstance;


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

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

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





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

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

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

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


    private:
      ::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIRawElementProviderSimple(::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ UnwrapIRawElementProviderSimple(Local<Value> value);
  };

  Persistent<FunctionTemplate> IRawElementProviderSimple::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::IRawElementProviderSimple^ UnwrapIRawElementProviderSimple(Local<Value> value) {
     return IRawElementProviderSimple::Unwrap<IRawElementProviderSimple>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIRawElementProviderSimple(Local<Object> exports) {
    IRawElementProviderSimple::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "navigateCustom", NavigateCustom);
          




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



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

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

    private:

      ICustomNavigationProvider(::Windows::UI::Xaml::Automation::Provider::ICustomNavigationProvider^ 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::Xaml::Automation::Provider::ICustomNavigationProvider^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ICustomNavigationProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::UI::Xaml::Automation::Peers::AutomationNavigationDirection arg0 = static_cast<::Windows::UI::Xaml::Automation::Peers::AutomationNavigationDirection>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          ::Platform::Object^ result;
          result = wrapper->_instance->NavigateCustom(arg0);
          info.GetReturnValue().Set(CreateOpaqueWrapper(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





    private:
      ::Windows::UI::Xaml::Automation::Provider::ICustomNavigationProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapICustomNavigationProvider(::Windows::UI::Xaml::Automation::Provider::ICustomNavigationProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::ICustomNavigationProvider^ UnwrapICustomNavigationProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> ICustomNavigationProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::ICustomNavigationProvider^ UnwrapICustomNavigationProvider(Local<Value> value) {
     return ICustomNavigationProvider::Unwrap<ICustomNavigationProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitICustomNavigationProvider(Local<Object> exports) {
    ICustomNavigationProvider::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getActiveComposition", GetActiveComposition);
            Nan::SetPrototypeMethod(localRef, "getConversionTarget", GetConversionTarget);
          




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



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

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

    private:

      ITextEditProvider(::Windows::UI::Xaml::Automation::Provider::ITextEditProvider^ 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::Xaml::Automation::Provider::ITextEditProvider^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextEditProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^ result;
          result = wrapper->_instance->GetActiveComposition();
          info.GetReturnValue().Set(WrapITextRangeProvider(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetConversionTarget(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Xaml::Automation::Provider::ITextEditProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::UI::Xaml::Automation::Provider::ITextRangeProvider^ result;
          result = wrapper->_instance->GetConversionTarget();
          info.GetReturnValue().Set(WrapITextRangeProvider(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::Xaml::Automation::Provider::ITextEditProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapITextEditProvider(::Windows::UI::Xaml::Automation::Provider::ITextEditProvider^ wintRtInstance);
      friend ::Windows::UI::Xaml::Automation::Provider::ITextEditProvider^ UnwrapITextEditProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> ITextEditProvider::s_constructorTemplate;

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

  ::Windows::UI::Xaml::Automation::Provider::ITextEditProvider^ UnwrapITextEditProvider(Local<Value> value) {
     return ITextEditProvider::Unwrap<ITextEditProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitITextEditProvider(Local<Object> exports) {
    ITextEditProvider::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::Xaml::Automation::Provider::InitIAnnotationProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitIDockProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitIDragProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitIDropTargetProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitIExpandCollapseProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitIGridItemProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitIGridProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitIInvokeProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitIItemContainerProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitIMultipleViewProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitIObjectModelProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitIRangeValueProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitIScrollItemProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitIScrollProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitISelectionItemProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitISelectionProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitISpreadsheetItemProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitISpreadsheetProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitIStylesProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitISynchronizedInputProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitITableItemProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitITableProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitITextChildProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitITextRangeProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitITextProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitITextProvider2(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitITextRangeProvider2(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitIToggleProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitITransformProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitITransformProvider2(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitIValueProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitIVirtualizedItemProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitIWindowProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitIRawElementProviderSimple(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitICustomNavigationProvider(target);
      NodeRT::Windows::UI::Xaml::Automation::Provider::InitITextEditProvider(target);


  NodeRT::Utils::RegisterNameSpace("Windows.UI.Xaml.Automation.Provider", target);
}



NODE_MODULE(binding, init)