// 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 AI { namespace MachineLearning { 
  v8::Local<v8::Value> WrapILearningModelFeatureDescriptor(::Windows::AI::MachineLearning::ILearningModelFeatureDescriptor^ wintRtInstance);
  ::Windows::AI::MachineLearning::ILearningModelFeatureDescriptor^ UnwrapILearningModelFeatureDescriptor(Local<Value> value);
  
  v8::Local<v8::Value> WrapILearningModelFeatureValue(::Windows::AI::MachineLearning::ILearningModelFeatureValue^ wintRtInstance);
  ::Windows::AI::MachineLearning::ILearningModelFeatureValue^ UnwrapILearningModelFeatureValue(Local<Value> value);
  
  v8::Local<v8::Value> WrapILearningModelOperatorProvider(::Windows::AI::MachineLearning::ILearningModelOperatorProvider^ wintRtInstance);
  ::Windows::AI::MachineLearning::ILearningModelOperatorProvider^ UnwrapILearningModelOperatorProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapITensor(::Windows::AI::MachineLearning::ITensor^ wintRtInstance);
  ::Windows::AI::MachineLearning::ITensor^ UnwrapITensor(Local<Value> value);
  
  v8::Local<v8::Value> WrapImageFeatureDescriptor(::Windows::AI::MachineLearning::ImageFeatureDescriptor^ wintRtInstance);
  ::Windows::AI::MachineLearning::ImageFeatureDescriptor^ UnwrapImageFeatureDescriptor(Local<Value> value);
  
  v8::Local<v8::Value> WrapImageFeatureValue(::Windows::AI::MachineLearning::ImageFeatureValue^ wintRtInstance);
  ::Windows::AI::MachineLearning::ImageFeatureValue^ UnwrapImageFeatureValue(Local<Value> value);
  
  v8::Local<v8::Value> WrapLearningModel(::Windows::AI::MachineLearning::LearningModel^ wintRtInstance);
  ::Windows::AI::MachineLearning::LearningModel^ UnwrapLearningModel(Local<Value> value);
  
  v8::Local<v8::Value> WrapLearningModelBinding(::Windows::AI::MachineLearning::LearningModelBinding^ wintRtInstance);
  ::Windows::AI::MachineLearning::LearningModelBinding^ UnwrapLearningModelBinding(Local<Value> value);
  
  v8::Local<v8::Value> WrapLearningModelDevice(::Windows::AI::MachineLearning::LearningModelDevice^ wintRtInstance);
  ::Windows::AI::MachineLearning::LearningModelDevice^ UnwrapLearningModelDevice(Local<Value> value);
  
  v8::Local<v8::Value> WrapLearningModelEvaluationResult(::Windows::AI::MachineLearning::LearningModelEvaluationResult^ wintRtInstance);
  ::Windows::AI::MachineLearning::LearningModelEvaluationResult^ UnwrapLearningModelEvaluationResult(Local<Value> value);
  
  v8::Local<v8::Value> WrapLearningModelSession(::Windows::AI::MachineLearning::LearningModelSession^ wintRtInstance);
  ::Windows::AI::MachineLearning::LearningModelSession^ UnwrapLearningModelSession(Local<Value> value);
  
  v8::Local<v8::Value> WrapLearningModelSessionOptions(::Windows::AI::MachineLearning::LearningModelSessionOptions^ wintRtInstance);
  ::Windows::AI::MachineLearning::LearningModelSessionOptions^ UnwrapLearningModelSessionOptions(Local<Value> value);
  
  v8::Local<v8::Value> WrapMapFeatureDescriptor(::Windows::AI::MachineLearning::MapFeatureDescriptor^ wintRtInstance);
  ::Windows::AI::MachineLearning::MapFeatureDescriptor^ UnwrapMapFeatureDescriptor(Local<Value> value);
  
  v8::Local<v8::Value> WrapSequenceFeatureDescriptor(::Windows::AI::MachineLearning::SequenceFeatureDescriptor^ wintRtInstance);
  ::Windows::AI::MachineLearning::SequenceFeatureDescriptor^ UnwrapSequenceFeatureDescriptor(Local<Value> value);
  
  v8::Local<v8::Value> WrapTensorBoolean(::Windows::AI::MachineLearning::TensorBoolean^ wintRtInstance);
  ::Windows::AI::MachineLearning::TensorBoolean^ UnwrapTensorBoolean(Local<Value> value);
  
  v8::Local<v8::Value> WrapTensorDouble(::Windows::AI::MachineLearning::TensorDouble^ wintRtInstance);
  ::Windows::AI::MachineLearning::TensorDouble^ UnwrapTensorDouble(Local<Value> value);
  
  v8::Local<v8::Value> WrapTensorFeatureDescriptor(::Windows::AI::MachineLearning::TensorFeatureDescriptor^ wintRtInstance);
  ::Windows::AI::MachineLearning::TensorFeatureDescriptor^ UnwrapTensorFeatureDescriptor(Local<Value> value);
  
  v8::Local<v8::Value> WrapTensorFloat(::Windows::AI::MachineLearning::TensorFloat^ wintRtInstance);
  ::Windows::AI::MachineLearning::TensorFloat^ UnwrapTensorFloat(Local<Value> value);
  
  v8::Local<v8::Value> WrapTensorFloat16Bit(::Windows::AI::MachineLearning::TensorFloat16Bit^ wintRtInstance);
  ::Windows::AI::MachineLearning::TensorFloat16Bit^ UnwrapTensorFloat16Bit(Local<Value> value);
  
  v8::Local<v8::Value> WrapTensorInt16Bit(::Windows::AI::MachineLearning::TensorInt16Bit^ wintRtInstance);
  ::Windows::AI::MachineLearning::TensorInt16Bit^ UnwrapTensorInt16Bit(Local<Value> value);
  
  v8::Local<v8::Value> WrapTensorInt32Bit(::Windows::AI::MachineLearning::TensorInt32Bit^ wintRtInstance);
  ::Windows::AI::MachineLearning::TensorInt32Bit^ UnwrapTensorInt32Bit(Local<Value> value);
  
  v8::Local<v8::Value> WrapTensorInt64Bit(::Windows::AI::MachineLearning::TensorInt64Bit^ wintRtInstance);
  ::Windows::AI::MachineLearning::TensorInt64Bit^ UnwrapTensorInt64Bit(Local<Value> value);
  
  v8::Local<v8::Value> WrapTensorInt8Bit(::Windows::AI::MachineLearning::TensorInt8Bit^ wintRtInstance);
  ::Windows::AI::MachineLearning::TensorInt8Bit^ UnwrapTensorInt8Bit(Local<Value> value);
  
  v8::Local<v8::Value> WrapTensorString(::Windows::AI::MachineLearning::TensorString^ wintRtInstance);
  ::Windows::AI::MachineLearning::TensorString^ UnwrapTensorString(Local<Value> value);
  
  v8::Local<v8::Value> WrapTensorUInt16Bit(::Windows::AI::MachineLearning::TensorUInt16Bit^ wintRtInstance);
  ::Windows::AI::MachineLearning::TensorUInt16Bit^ UnwrapTensorUInt16Bit(Local<Value> value);
  
  v8::Local<v8::Value> WrapTensorUInt32Bit(::Windows::AI::MachineLearning::TensorUInt32Bit^ wintRtInstance);
  ::Windows::AI::MachineLearning::TensorUInt32Bit^ UnwrapTensorUInt32Bit(Local<Value> value);
  
  v8::Local<v8::Value> WrapTensorUInt64Bit(::Windows::AI::MachineLearning::TensorUInt64Bit^ wintRtInstance);
  ::Windows::AI::MachineLearning::TensorUInt64Bit^ UnwrapTensorUInt64Bit(Local<Value> value);
  
  v8::Local<v8::Value> WrapTensorUInt8Bit(::Windows::AI::MachineLearning::TensorUInt8Bit^ wintRtInstance);
  ::Windows::AI::MachineLearning::TensorUInt8Bit^ UnwrapTensorUInt8Bit(Local<Value> value);
  



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

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

    Nan::Set(exports, Nan::New<String>("LearningModelDeviceKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("default").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::AI::MachineLearning::LearningModelDeviceKind::Default)));
    Nan::Set(enumObject, Nan::New<String>("cpu").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::AI::MachineLearning::LearningModelDeviceKind::Cpu)));
    Nan::Set(enumObject, Nan::New<String>("directX").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::AI::MachineLearning::LearningModelDeviceKind::DirectX)));
    Nan::Set(enumObject, Nan::New<String>("directXHighPerformance").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::AI::MachineLearning::LearningModelDeviceKind::DirectXHighPerformance)));
    Nan::Set(enumObject, Nan::New<String>("directXMinPower").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::AI::MachineLearning::LearningModelDeviceKind::DirectXMinPower)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("LearningModelFeatureKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("tensor").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::AI::MachineLearning::LearningModelFeatureKind::Tensor)));
    Nan::Set(enumObject, Nan::New<String>("sequence").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::AI::MachineLearning::LearningModelFeatureKind::Sequence)));
    Nan::Set(enumObject, Nan::New<String>("map").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::AI::MachineLearning::LearningModelFeatureKind::Map)));
    Nan::Set(enumObject, Nan::New<String>("image").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::AI::MachineLearning::LearningModelFeatureKind::Image)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("LearningModelPixelRange").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("zeroTo255").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::AI::MachineLearning::LearningModelPixelRange::ZeroTo255)));
    Nan::Set(enumObject, Nan::New<String>("zeroToOne").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::AI::MachineLearning::LearningModelPixelRange::ZeroToOne)));
    Nan::Set(enumObject, Nan::New<String>("minusOneToOne").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::AI::MachineLearning::LearningModelPixelRange::MinusOneToOne)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("TensorKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("undefined").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::AI::MachineLearning::TensorKind::Undefined)));
    Nan::Set(enumObject, Nan::New<String>("float").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::AI::MachineLearning::TensorKind::Float)));
    Nan::Set(enumObject, Nan::New<String>("uInt8").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::AI::MachineLearning::TensorKind::UInt8)));
    Nan::Set(enumObject, Nan::New<String>("int8").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::AI::MachineLearning::TensorKind::Int8)));
    Nan::Set(enumObject, Nan::New<String>("uInt16").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::AI::MachineLearning::TensorKind::UInt16)));
    Nan::Set(enumObject, Nan::New<String>("int16").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::AI::MachineLearning::TensorKind::Int16)));
    Nan::Set(enumObject, Nan::New<String>("int32").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::AI::MachineLearning::TensorKind::Int32)));
    Nan::Set(enumObject, Nan::New<String>("int64").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::AI::MachineLearning::TensorKind::Int64)));
    Nan::Set(enumObject, Nan::New<String>("string").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::AI::MachineLearning::TensorKind::String)));
    Nan::Set(enumObject, Nan::New<String>("boolean").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::AI::MachineLearning::TensorKind::Boolean)));
    Nan::Set(enumObject, Nan::New<String>("float16").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::AI::MachineLearning::TensorKind::Float16)));
    Nan::Set(enumObject, Nan::New<String>("double").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::AI::MachineLearning::TensorKind::Double)));
    Nan::Set(enumObject, Nan::New<String>("uInt32").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::AI::MachineLearning::TensorKind::UInt32)));
    Nan::Set(enumObject, Nan::New<String>("uInt64").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::AI::MachineLearning::TensorKind::UInt64)));
    Nan::Set(enumObject, Nan::New<String>("complex64").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::AI::MachineLearning::TensorKind::Complex64)));
    Nan::Set(enumObject, Nan::New<String>("complex128").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::AI::MachineLearning::TensorKind::Complex128)));
  }

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

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

    return true;
  }

  ::Windows::AI::MachineLearning::MachineLearningContract MachineLearningContractFromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::AI::MachineLearning::MachineLearningContract 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> MachineLearningContractToJsObject(::Windows::AI::MachineLearning::MachineLearningContract value) {
    EscapableHandleScope scope;

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


    return scope.Escape(obj);
  }

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

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

    symbol = Nan::New<String>("lowPart").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsUint32()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("highPart").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsInt32()) {
        return false;
      }
    }
    
    return true;
  }

  ::Windows::Graphics::DisplayAdapterId DisplayAdapterIdFromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::Graphics::DisplayAdapterId returnValue;

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

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

    symbol = Nan::New<String>("lowPart").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.LowPart = static_cast<unsigned int>(Nan::To<uint32_t>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0));
    }
    
    symbol = Nan::New<String>("highPart").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.HighPart = static_cast<int>(Nan::To<int32_t>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0));
    }
    
    return returnValue;
  }

  Local<Value> DisplayAdapterIdToJsObject(::Windows::Graphics::DisplayAdapterId value) {
    EscapableHandleScope scope;

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

    Nan::Set(obj, Nan::New<String>("lowPart").ToLocalChecked(), Nan::New<Integer>(value.LowPart));
    Nan::Set(obj, Nan::New<String>("highPart").ToLocalChecked(), Nan::New<Integer>(value.HighPart));

    return scope.Escape(obj);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("description").ToLocalChecked(), DescriptionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isRequired").ToLocalChecked(), IsRequiredGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("name").ToLocalChecked(), NameGetter);

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



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

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

    private:

      ILearningModelFeatureDescriptor(::Windows::AI::MachineLearning::ILearningModelFeatureDescriptor^ 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::AI::MachineLearning::ILearningModelFeatureDescriptor^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::ILearningModelFeatureDescriptor^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::ILearningModelFeatureDescriptor^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::ILearningModelFeatureDescriptor^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::ILearningModelFeatureDescriptor^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::AI::MachineLearning::ILearningModelFeatureDescriptor^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapILearningModelFeatureDescriptor(::Windows::AI::MachineLearning::ILearningModelFeatureDescriptor^ wintRtInstance);
      friend ::Windows::AI::MachineLearning::ILearningModelFeatureDescriptor^ UnwrapILearningModelFeatureDescriptor(Local<Value> value);
  };

  Persistent<FunctionTemplate> ILearningModelFeatureDescriptor::s_constructorTemplate;

  v8::Local<v8::Value> WrapILearningModelFeatureDescriptor(::Windows::AI::MachineLearning::ILearningModelFeatureDescriptor^ 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>(ILearningModelFeatureDescriptor::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::AI::MachineLearning::ILearningModelFeatureDescriptor^ UnwrapILearningModelFeatureDescriptor(Local<Value> value) {
     return ILearningModelFeatureDescriptor::Unwrap<ILearningModelFeatureDescriptor>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitILearningModelFeatureDescriptor(Local<Object> exports) {
    ILearningModelFeatureDescriptor::Init(exports);
  }

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





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

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



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

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

    private:

      ILearningModelFeatureValue(::Windows::AI::MachineLearning::ILearningModelFeatureValue^ 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::AI::MachineLearning::ILearningModelFeatureValue^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::ILearningModelFeatureValue^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::AI::MachineLearning::ILearningModelFeatureValue^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapILearningModelFeatureValue(::Windows::AI::MachineLearning::ILearningModelFeatureValue^ wintRtInstance);
      friend ::Windows::AI::MachineLearning::ILearningModelFeatureValue^ UnwrapILearningModelFeatureValue(Local<Value> value);
  };

  Persistent<FunctionTemplate> ILearningModelFeatureValue::s_constructorTemplate;

  v8::Local<v8::Value> WrapILearningModelFeatureValue(::Windows::AI::MachineLearning::ILearningModelFeatureValue^ 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>(ILearningModelFeatureValue::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::AI::MachineLearning::ILearningModelFeatureValue^ UnwrapILearningModelFeatureValue(Local<Value> value) {
     return ILearningModelFeatureValue::Unwrap<ILearningModelFeatureValue>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitILearningModelFeatureValue(Local<Object> exports) {
    ILearningModelFeatureValue::Init(exports);
  }

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






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



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

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

    private:

      ILearningModelOperatorProvider(::Windows::AI::MachineLearning::ILearningModelOperatorProvider^ 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::AI::MachineLearning::ILearningModelOperatorProvider^ winRtInstance;


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

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

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







    private:
      ::Windows::AI::MachineLearning::ILearningModelOperatorProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapILearningModelOperatorProvider(::Windows::AI::MachineLearning::ILearningModelOperatorProvider^ wintRtInstance);
      friend ::Windows::AI::MachineLearning::ILearningModelOperatorProvider^ UnwrapILearningModelOperatorProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> ILearningModelOperatorProvider::s_constructorTemplate;

  v8::Local<v8::Value> WrapILearningModelOperatorProvider(::Windows::AI::MachineLearning::ILearningModelOperatorProvider^ 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>(ILearningModelOperatorProvider::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::AI::MachineLearning::ILearningModelOperatorProvider^ UnwrapILearningModelOperatorProvider(Local<Value> value) {
     return ILearningModelOperatorProvider::Unwrap<ILearningModelOperatorProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitILearningModelOperatorProvider(Local<Object> exports) {
    ILearningModelOperatorProvider::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("shape").ToLocalChecked(), ShapeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("tensorKind").ToLocalChecked(), TensorKindGetter);

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



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

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

    private:

      ITensor(::Windows::AI::MachineLearning::ITensor^ 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::AI::MachineLearning::ITensor^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::ITensor^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<__int64>^ result = wrapper->_instance->Shape;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<__int64>::CreateVectorViewWrapper(result, 
            [](__int64 val) -> Local<Value> {
              return Nan::New<Number>(static_cast<double>(val));
            },
            [](Local<Value> value) -> bool {
              return value->IsNumber();
            },
            [](Local<Value> value) -> __int64 {
              return Nan::To<int64_t>(value).FromMaybe(0);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TensorKindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::ITensor^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::AI::MachineLearning::ITensor^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapITensor(::Windows::AI::MachineLearning::ITensor^ wintRtInstance);
      friend ::Windows::AI::MachineLearning::ITensor^ UnwrapITensor(Local<Value> value);
  };

  Persistent<FunctionTemplate> ITensor::s_constructorTemplate;

  v8::Local<v8::Value> WrapITensor(::Windows::AI::MachineLearning::ITensor^ 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>(ITensor::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::AI::MachineLearning::ITensor^ UnwrapITensor(Local<Value> value) {
     return ITensor::Unwrap<ITensor>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitITensor(Local<Object> exports) {
    ITensor::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("bitmapAlphaMode").ToLocalChecked(), BitmapAlphaModeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("bitmapPixelFormat").ToLocalChecked(), BitmapPixelFormatGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("height").ToLocalChecked(), HeightGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("width").ToLocalChecked(), WidthGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pixelRange").ToLocalChecked(), PixelRangeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("description").ToLocalChecked(), DescriptionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isRequired").ToLocalChecked(), IsRequiredGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("name").ToLocalChecked(), NameGetter);

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



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

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

    private:

      ImageFeatureDescriptor(::Windows::AI::MachineLearning::ImageFeatureDescriptor^ 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::AI::MachineLearning::ImageFeatureDescriptor^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::ImageFeatureDescriptor^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::ImageFeatureDescriptor^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::ImageFeatureDescriptor^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::ImageFeatureDescriptor^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::ImageFeatureDescriptor^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::ImageFeatureDescriptor^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::ImageFeatureDescriptor^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::ImageFeatureDescriptor^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::ImageFeatureDescriptor^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::AI::MachineLearning::ImageFeatureDescriptor^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapImageFeatureDescriptor(::Windows::AI::MachineLearning::ImageFeatureDescriptor^ wintRtInstance);
      friend ::Windows::AI::MachineLearning::ImageFeatureDescriptor^ UnwrapImageFeatureDescriptor(Local<Value> value);
  };

  Persistent<FunctionTemplate> ImageFeatureDescriptor::s_constructorTemplate;

  v8::Local<v8::Value> WrapImageFeatureDescriptor(::Windows::AI::MachineLearning::ImageFeatureDescriptor^ 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>(ImageFeatureDescriptor::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::AI::MachineLearning::ImageFeatureDescriptor^ UnwrapImageFeatureDescriptor(Local<Value> value) {
     return ImageFeatureDescriptor::Unwrap<ImageFeatureDescriptor>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitImageFeatureDescriptor(Local<Object> exports) {
    ImageFeatureDescriptor::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoFrame").ToLocalChecked(), VideoFrameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);

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

        Nan::SetMethod(constructor, "createFromVideoFrame", CreateFromVideoFrame);


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

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

    private:

      ImageFeatureValue(::Windows::AI::MachineLearning::ImageFeatureValue^ 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::AI::MachineLearning::ImageFeatureValue^ winRtInstance;


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

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

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





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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::VideoFrame^>(info[0]))
      {
        try
        {
          ::Windows::Media::VideoFrame^ arg0 = dynamic_cast<::Windows::Media::VideoFrame^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::AI::MachineLearning::ImageFeatureValue^ result;
          result = ::Windows::AI::MachineLearning::ImageFeatureValue::CreateFromVideoFrame(arg0);
          info.GetReturnValue().Set(WrapImageFeatureValue(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 VideoFrameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::ImageFeatureValue^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::ImageFeatureValue^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::AI::MachineLearning::ImageFeatureValue^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapImageFeatureValue(::Windows::AI::MachineLearning::ImageFeatureValue^ wintRtInstance);
      friend ::Windows::AI::MachineLearning::ImageFeatureValue^ UnwrapImageFeatureValue(Local<Value> value);
  };

  Persistent<FunctionTemplate> ImageFeatureValue::s_constructorTemplate;

  v8::Local<v8::Value> WrapImageFeatureValue(::Windows::AI::MachineLearning::ImageFeatureValue^ 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>(ImageFeatureValue::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::AI::MachineLearning::ImageFeatureValue^ UnwrapImageFeatureValue(Local<Value> value) {
     return ImageFeatureValue::Unwrap<ImageFeatureValue>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitImageFeatureValue(Local<Object> exports) {
    ImageFeatureValue::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "close", Close);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("author").ToLocalChecked(), AuthorGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("description").ToLocalChecked(), DescriptionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("domain").ToLocalChecked(), DomainGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("inputFeatures").ToLocalChecked(), InputFeaturesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("metadata").ToLocalChecked(), MetadataGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("name").ToLocalChecked(), NameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("outputFeatures").ToLocalChecked(), OutputFeaturesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("version").ToLocalChecked(), VersionGetter);

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

        Nan::SetMethod(constructor, "loadFromFilePath", LoadFromFilePath);
        Nan::SetMethod(constructor, "loadFromStream", LoadFromStream);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(LoadFromStorageFileAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("loadFromStorageFileAsync").ToLocalChecked(), func);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(LoadFromStreamAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("loadFromStreamAsync").ToLocalChecked(), func);


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

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

    private:

      LearningModel(::Windows::AI::MachineLearning::LearningModel^ 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::AI::MachineLearning::LearningModel^ winRtInstance;


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

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

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



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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModel^>(info.This())) {
        return;
      }

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

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::AI::MachineLearning::LearningModel^>^ op;


      if (info.Length() == 2
          && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::IStorageFile^>(info[0]))
      {
        try
        {
          ::Windows::Storage::IStorageFile^ arg0 = dynamic_cast<::Windows::Storage::IStorageFile^>(NodeRT::Utils::GetObjectInstance(info[0]));
            
          op = ::Windows::AI::MachineLearning::LearningModel::LoadFromStorageFileAsync(arg0);
        } catch (Platform::Exception ^exception) {
            NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
            return;
        }
      }
      else if (info.Length() == 3
          && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::IStorageFile^>(info[0])
          && NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::ILearningModelOperatorProvider^>(info[1]))
      {
        try
        {
          ::Windows::Storage::IStorageFile^ arg0 = dynamic_cast<::Windows::Storage::IStorageFile^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::AI::MachineLearning::ILearningModelOperatorProvider^ arg1 = UnwrapILearningModelOperatorProvider(info[1]);
            
          op = ::Windows::AI::MachineLearning::LearningModel::LoadFromStorageFileAsync(arg0,arg1);
        } catch (Platform::Exception ^exception) {
            NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
            return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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


            invokeCallback(_countof(args), args);
          });
        }
        catch (Platform::Exception^ exception)
        {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {

            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

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

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::AI::MachineLearning::LearningModel^>^ op;


      if (info.Length() == 2
          && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IRandomAccessStreamReference^>(info[0]))
      {
        try
        {
          ::Windows::Storage::Streams::IRandomAccessStreamReference^ arg0 = dynamic_cast<::Windows::Storage::Streams::IRandomAccessStreamReference^>(NodeRT::Utils::GetObjectInstance(info[0]));
            
          op = ::Windows::AI::MachineLearning::LearningModel::LoadFromStreamAsync(arg0);
        } catch (Platform::Exception ^exception) {
            NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
            return;
        }
      }
      else if (info.Length() == 3
          && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IRandomAccessStreamReference^>(info[0])
          && NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::ILearningModelOperatorProvider^>(info[1]))
      {
        try
        {
          ::Windows::Storage::Streams::IRandomAccessStreamReference^ arg0 = dynamic_cast<::Windows::Storage::Streams::IRandomAccessStreamReference^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::AI::MachineLearning::ILearningModelOperatorProvider^ arg1 = UnwrapILearningModelOperatorProvider(info[1]);
            
          op = ::Windows::AI::MachineLearning::LearningModel::LoadFromStreamAsync(arg0,arg1);
        } catch (Platform::Exception ^exception) {
            NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
            return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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


            invokeCallback(_countof(args), args);
          });
        }
        catch (Platform::Exception^ exception)
        {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {

            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

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


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

      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::AI::MachineLearning::LearningModel^ result;
          result = ::Windows::AI::MachineLearning::LearningModel::LoadFromFilePath(arg0);
          info.GetReturnValue().Set(WrapLearningModel(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && info[0]->IsString()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::ILearningModelOperatorProvider^>(info[1]))
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::AI::MachineLearning::ILearningModelOperatorProvider^ arg1 = UnwrapILearningModelOperatorProvider(info[1]);
          
          ::Windows::AI::MachineLearning::LearningModel^ result;
          result = ::Windows::AI::MachineLearning::LearningModel::LoadFromFilePath(arg0, arg1);
          info.GetReturnValue().Set(WrapLearningModel(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 LoadFromStream(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IRandomAccessStreamReference^>(info[0]))
      {
        try
        {
          ::Windows::Storage::Streams::IRandomAccessStreamReference^ arg0 = dynamic_cast<::Windows::Storage::Streams::IRandomAccessStreamReference^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::AI::MachineLearning::LearningModel^ result;
          result = ::Windows::AI::MachineLearning::LearningModel::LoadFromStream(arg0);
          info.GetReturnValue().Set(WrapLearningModel(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IRandomAccessStreamReference^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::ILearningModelOperatorProvider^>(info[1]))
      {
        try
        {
          ::Windows::Storage::Streams::IRandomAccessStreamReference^ arg0 = dynamic_cast<::Windows::Storage::Streams::IRandomAccessStreamReference^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::AI::MachineLearning::ILearningModelOperatorProvider^ arg1 = UnwrapILearningModelOperatorProvider(info[1]);
          
          ::Windows::AI::MachineLearning::LearningModel^ result;
          result = ::Windows::AI::MachineLearning::LearningModel::LoadFromStream(arg0, arg1);
          info.GetReturnValue().Set(WrapLearningModel(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 AuthorGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModel^>(info.This())) {
        return;
      }

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModel^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModel^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModel^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::AI::MachineLearning::ILearningModelFeatureDescriptor^>^ result = wrapper->_instance->InputFeatures;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::AI::MachineLearning::ILearningModelFeatureDescriptor^>::CreateVectorViewWrapper(result, 
            [](::Windows::AI::MachineLearning::ILearningModelFeatureDescriptor^ val) -> Local<Value> {
              return WrapILearningModelFeatureDescriptor(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::ILearningModelFeatureDescriptor^>(value);
            },
            [](Local<Value> value) -> ::Windows::AI::MachineLearning::ILearningModelFeatureDescriptor^ {
              return UnwrapILearningModelFeatureDescriptor(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MetadataGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModel^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IMapView<::Platform::String^, ::Platform::String^>^ result = wrapper->_instance->Metadata;
        info.GetReturnValue().Set(NodeRT::Collections::MapViewWrapper<::Platform::String^,::Platform::String^>::CreateMapViewWrapper(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)));
            },
            [](::Platform::String^ val) -> Local<Value> {
              return NodeRT::Utils::NewString(val->Data());
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void NameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModel^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModel^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::AI::MachineLearning::ILearningModelFeatureDescriptor^>^ result = wrapper->_instance->OutputFeatures;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::AI::MachineLearning::ILearningModelFeatureDescriptor^>::CreateVectorViewWrapper(result, 
            [](::Windows::AI::MachineLearning::ILearningModelFeatureDescriptor^ val) -> Local<Value> {
              return WrapILearningModelFeatureDescriptor(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::ILearningModelFeatureDescriptor^>(value);
            },
            [](Local<Value> value) -> ::Windows::AI::MachineLearning::ILearningModelFeatureDescriptor^ {
              return UnwrapILearningModelFeatureDescriptor(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VersionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModel^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::AI::MachineLearning::LearningModel^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapLearningModel(::Windows::AI::MachineLearning::LearningModel^ wintRtInstance);
      friend ::Windows::AI::MachineLearning::LearningModel^ UnwrapLearningModel(Local<Value> value);
  };

  Persistent<FunctionTemplate> LearningModel::s_constructorTemplate;

  v8::Local<v8::Value> WrapLearningModel(::Windows::AI::MachineLearning::LearningModel^ 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>(LearningModel::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::AI::MachineLearning::LearningModel^ UnwrapLearningModel(Local<Value> value) {
     return LearningModel::Unwrap<LearningModel>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitLearningModel(Local<Object> exports) {
    LearningModel::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "bind", Bind);
            Nan::SetPrototypeMethod(localRef, "clear", Clear);
            Nan::SetPrototypeMethod(localRef, "lookup", Lookup);
            Nan::SetPrototypeMethod(localRef, "hasKey", HasKey);
            Nan::SetPrototypeMethod(localRef, "split", Split);
            Nan::SetPrototypeMethod(localRef, "first", First);
          




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



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

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

    private:

      LearningModelBinding(::Windows::AI::MachineLearning::LearningModelBinding^ 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::AI::MachineLearning::LearningModelBinding^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelBinding^>(info[0])) {
        try {
          winRtInstance = (::Windows::AI::MachineLearning::LearningModelBinding^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelSession^>(info[0]))
      {
        try {
          ::Windows::AI::MachineLearning::LearningModelSession^ arg0 = UnwrapLearningModelSession(info[0]);
          
          winRtInstance = ref new ::Windows::AI::MachineLearning::LearningModelBinding(arg0);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelBinding^>(info.This())) {
        return;
      }

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

      if (info.Length() == 2
        && info[0]->IsString()
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[1]))
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Platform::Object^ arg1 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          wrapper->_instance->Bind(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && info[0]->IsString()
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[1])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IPropertySet^>(info[2]))
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Platform::Object^ arg1 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[1]));
          ::Windows::Foundation::Collections::IPropertySet^ arg2 = dynamic_cast<::Windows::Foundation::Collections::IPropertySet^>(NodeRT::Utils::GetObjectInstance(info[2]));
          
          wrapper->_instance->Bind(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 Clear(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelBinding^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelBinding^>(info.This())) {
        return;
      }

      LearningModelBinding *wrapper = LearningModelBinding::Unwrap<LearningModelBinding>(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])));
          
          ::Platform::Object^ result;
          result = wrapper->_instance->Lookup(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 HasKey(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelBinding^>(info.This())) {
        return;
      }

      LearningModelBinding *wrapper = LearningModelBinding::Unwrap<LearningModelBinding>(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])));
          
          bool result;
          result = wrapper->_instance->HasKey(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 Split(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelBinding^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IMapView<::Platform::String^, ::Platform::Object^>^ arg0;
          ::Windows::Foundation::Collections::IMapView<::Platform::String^, ::Platform::Object^>^ arg1;
          
          wrapper->_instance->Split(&arg0, &arg1);
          Local<Object> resObj = Nan::New<Object>();
          Nan::Set(resObj, Nan::New<String>("first").ToLocalChecked(), NodeRT::Collections::MapViewWrapper<::Platform::String^,::Platform::Object^>::CreateMapViewWrapper(arg0, 
            [](::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)));
            },
            [](::Platform::Object^ val) -> Local<Value> {
              return CreateOpaqueWrapper(val);
            }
          ));
          Nan::Set(resObj, Nan::New<String>("second").ToLocalChecked(), NodeRT::Collections::MapViewWrapper<::Platform::String^,::Platform::Object^>::CreateMapViewWrapper(arg1, 
            [](::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)));
            },
            [](::Platform::Object^ val) -> Local<Value> {
              return CreateOpaqueWrapper(val);
            }
          ));
          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 First(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelBinding^>(info.This())) {
        return;
      }

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

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





    private:
      ::Windows::AI::MachineLearning::LearningModelBinding^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapLearningModelBinding(::Windows::AI::MachineLearning::LearningModelBinding^ wintRtInstance);
      friend ::Windows::AI::MachineLearning::LearningModelBinding^ UnwrapLearningModelBinding(Local<Value> value);
  };

  Persistent<FunctionTemplate> LearningModelBinding::s_constructorTemplate;

  v8::Local<v8::Value> WrapLearningModelBinding(::Windows::AI::MachineLearning::LearningModelBinding^ 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>(LearningModelBinding::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::AI::MachineLearning::LearningModelBinding^ UnwrapLearningModelBinding(Local<Value> value) {
     return LearningModelBinding::Unwrap<LearningModelBinding>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitLearningModelBinding(Local<Object> exports) {
    LearningModelBinding::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("adapterId").ToLocalChecked(), AdapterIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("direct3D11Device").ToLocalChecked(), Direct3D11DeviceGetter);

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

        Nan::SetMethod(constructor, "createFromDirect3D11Device", CreateFromDirect3D11Device);


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

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

    private:

      LearningModelDevice(::Windows::AI::MachineLearning::LearningModelDevice^ 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::AI::MachineLearning::LearningModelDevice^ winRtInstance;


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

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

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

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





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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::DirectX::Direct3D11::IDirect3DDevice^>(info[0]))
      {
        try
        {
          ::Windows::Graphics::DirectX::Direct3D11::IDirect3DDevice^ arg0 = dynamic_cast<::Windows::Graphics::DirectX::Direct3D11::IDirect3DDevice^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::AI::MachineLearning::LearningModelDevice^ result;
          result = ::Windows::AI::MachineLearning::LearningModelDevice::CreateFromDirect3D11Device(arg0);
          info.GetReturnValue().Set(WrapLearningModelDevice(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 AdapterIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelDevice^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelDevice^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::AI::MachineLearning::LearningModelDevice^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapLearningModelDevice(::Windows::AI::MachineLearning::LearningModelDevice^ wintRtInstance);
      friend ::Windows::AI::MachineLearning::LearningModelDevice^ UnwrapLearningModelDevice(Local<Value> value);
  };

  Persistent<FunctionTemplate> LearningModelDevice::s_constructorTemplate;

  v8::Local<v8::Value> WrapLearningModelDevice(::Windows::AI::MachineLearning::LearningModelDevice^ 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>(LearningModelDevice::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::AI::MachineLearning::LearningModelDevice^ UnwrapLearningModelDevice(Local<Value> value) {
     return LearningModelDevice::Unwrap<LearningModelDevice>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitLearningModelDevice(Local<Object> exports) {
    LearningModelDevice::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("correlationId").ToLocalChecked(), CorrelationIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("errorStatus").ToLocalChecked(), ErrorStatusGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("outputs").ToLocalChecked(), OutputsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("succeeded").ToLocalChecked(), SucceededGetter);

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



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

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

    private:

      LearningModelEvaluationResult(::Windows::AI::MachineLearning::LearningModelEvaluationResult^ 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::AI::MachineLearning::LearningModelEvaluationResult^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelEvaluationResult^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelEvaluationResult^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelEvaluationResult^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IMapView<::Platform::String^, ::Platform::Object^>^ result = wrapper->_instance->Outputs;
        info.GetReturnValue().Set(NodeRT::Collections::MapViewWrapper<::Platform::String^,::Platform::Object^>::CreateMapViewWrapper(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)));
            },
            [](::Platform::Object^ val) -> Local<Value> {
              return CreateOpaqueWrapper(val);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SucceededGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelEvaluationResult^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::AI::MachineLearning::LearningModelEvaluationResult^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapLearningModelEvaluationResult(::Windows::AI::MachineLearning::LearningModelEvaluationResult^ wintRtInstance);
      friend ::Windows::AI::MachineLearning::LearningModelEvaluationResult^ UnwrapLearningModelEvaluationResult(Local<Value> value);
  };

  Persistent<FunctionTemplate> LearningModelEvaluationResult::s_constructorTemplate;

  v8::Local<v8::Value> WrapLearningModelEvaluationResult(::Windows::AI::MachineLearning::LearningModelEvaluationResult^ 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>(LearningModelEvaluationResult::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::AI::MachineLearning::LearningModelEvaluationResult^ UnwrapLearningModelEvaluationResult(Local<Value> value) {
     return LearningModelEvaluationResult::Unwrap<LearningModelEvaluationResult>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitLearningModelEvaluationResult(Local<Object> exports) {
    LearningModelEvaluationResult::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "evaluate", Evaluate);
            Nan::SetPrototypeMethod(localRef, "evaluateFeatures", EvaluateFeatures);
            Nan::SetPrototypeMethod(localRef, "close", Close);
          

          
            Nan::SetPrototypeMethod(localRef, "evaluateAsync", EvaluateAsync);
            Nan::SetPrototypeMethod(localRef, "evaluateFeaturesAsync", EvaluateFeaturesAsync);
          


          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("device").ToLocalChecked(), DeviceGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("evaluationProperties").ToLocalChecked(), EvaluationPropertiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("model").ToLocalChecked(), ModelGetter);

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



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

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

    private:

      LearningModelSession(::Windows::AI::MachineLearning::LearningModelSession^ 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::AI::MachineLearning::LearningModelSession^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelSession^>(info[0])) {
        try {
          winRtInstance = (::Windows::AI::MachineLearning::LearningModelSession^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModel^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelDevice^>(info[1])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelSessionOptions^>(info[2]))
      {
        try {
          ::Windows::AI::MachineLearning::LearningModel^ arg0 = UnwrapLearningModel(info[0]);
          ::Windows::AI::MachineLearning::LearningModelDevice^ arg1 = UnwrapLearningModelDevice(info[1]);
          ::Windows::AI::MachineLearning::LearningModelSessionOptions^ arg2 = UnwrapLearningModelSessionOptions(info[2]);
          
          winRtInstance = ref new ::Windows::AI::MachineLearning::LearningModelSession(arg0,arg1,arg2);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModel^>(info[0]))
      {
        try {
          ::Windows::AI::MachineLearning::LearningModel^ arg0 = UnwrapLearningModel(info[0]);
          
          winRtInstance = ref new ::Windows::AI::MachineLearning::LearningModelSession(arg0);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModel^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelDevice^>(info[1]))
      {
        try {
          ::Windows::AI::MachineLearning::LearningModel^ arg0 = UnwrapLearningModel(info[0]);
          ::Windows::AI::MachineLearning::LearningModelDevice^ arg1 = UnwrapLearningModelDevice(info[1]);
          
          winRtInstance = ref new ::Windows::AI::MachineLearning::LearningModelSession(arg0,arg1);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelSession^>(info.This())) {
        return;
      }

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::AI::MachineLearning::LearningModelEvaluationResult^>^ op;


      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelBinding^>(info[0])
        && info[1]->IsString())
      {
        try
        {
          ::Windows::AI::MachineLearning::LearningModelBinding^ arg0 = UnwrapLearningModelBinding(info[0]);
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          
          op = wrapper->_instance->EvaluateAsync(arg0,arg1);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelSession^>(info.This())) {
        return;
      }

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::AI::MachineLearning::LearningModelEvaluationResult^>^ op;


      if (info.Length() == 3
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IMap<::Platform::String^, ::Platform::Object^>^>(info[0]) || info[0]->IsObject())
        && info[1]->IsString())
      {
        try
        {
          ::Windows::Foundation::Collections::IMap<::Platform::String^, ::Platform::Object^>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IMap<::Platform::String^, ::Platform::Object^>^
            {
              if (value->IsObject())
              {
                return NodeRT::Collections::JsObjectToWinrtMap<::Platform::Object^>(value.As<Object>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(value);
                 },
                 [](Local<Value> value) -> ::Platform::Object^ {
                   return dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IMap<::Platform::String^, ::Platform::Object^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          
          op = wrapper->_instance->EvaluateFeaturesAsync(arg0,arg1);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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


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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelSession^>(info.This())) {
        return;
      }

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

      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelBinding^>(info[0])
        && info[1]->IsString())
      {
        try
        {
          ::Windows::AI::MachineLearning::LearningModelBinding^ arg0 = UnwrapLearningModelBinding(info[0]);
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          
          ::Windows::AI::MachineLearning::LearningModelEvaluationResult^ result;
          result = wrapper->_instance->Evaluate(arg0, arg1);
          info.GetReturnValue().Set(WrapLearningModelEvaluationResult(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 EvaluateFeatures(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelSession^>(info.This())) {
        return;
      }

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

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IMap<::Platform::String^, ::Platform::Object^>^>(info[0]) || info[0]->IsObject())
        && info[1]->IsString())
      {
        try
        {
          ::Windows::Foundation::Collections::IMap<::Platform::String^, ::Platform::Object^>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IMap<::Platform::String^, ::Platform::Object^>^
            {
              if (value->IsObject())
              {
                return NodeRT::Collections::JsObjectToWinrtMap<::Platform::Object^>(value.As<Object>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(value);
                 },
                 [](Local<Value> value) -> ::Platform::Object^ {
                   return dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IMap<::Platform::String^, ::Platform::Object^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          
          ::Windows::AI::MachineLearning::LearningModelEvaluationResult^ result;
          result = wrapper->_instance->EvaluateFeatures(arg0, arg1);
          info.GetReturnValue().Set(WrapLearningModelEvaluationResult(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 Close(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelSession^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelSession^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::AI::MachineLearning::LearningModelDevice^ result = wrapper->_instance->Device;
        info.GetReturnValue().Set(WrapLearningModelDevice(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void EvaluationPropertiesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelSession^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelSession^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::AI::MachineLearning::LearningModel^ result = wrapper->_instance->Model;
        info.GetReturnValue().Set(WrapLearningModel(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::AI::MachineLearning::LearningModelSession^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapLearningModelSession(::Windows::AI::MachineLearning::LearningModelSession^ wintRtInstance);
      friend ::Windows::AI::MachineLearning::LearningModelSession^ UnwrapLearningModelSession(Local<Value> value);
  };

  Persistent<FunctionTemplate> LearningModelSession::s_constructorTemplate;

  v8::Local<v8::Value> WrapLearningModelSession(::Windows::AI::MachineLearning::LearningModelSession^ 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>(LearningModelSession::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::AI::MachineLearning::LearningModelSession^ UnwrapLearningModelSession(Local<Value> value) {
     return LearningModelSession::Unwrap<LearningModelSession>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitLearningModelSession(Local<Object> exports) {
    LearningModelSession::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "overrideNamedDimension", OverrideNamedDimension);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("batchSizeOverride").ToLocalChecked(), BatchSizeOverrideGetter, BatchSizeOverrideSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("closeModelOnSessionCreation").ToLocalChecked(), CloseModelOnSessionCreationGetter, CloseModelOnSessionCreationSetter);

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



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

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

    private:

      LearningModelSessionOptions(::Windows::AI::MachineLearning::LearningModelSessionOptions^ 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::AI::MachineLearning::LearningModelSessionOptions^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelSessionOptions^>(info.This())) {
        return;
      }

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

      if (info.Length() == 2
        && info[0]->IsString()
        && info[1]->IsUint32())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          unsigned int arg1 = static_cast<unsigned int>(Nan::To<uint32_t>(info[1]).FromMaybe(0));
          
          wrapper->_instance->OverrideNamedDimension(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 BatchSizeOverrideGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelSessionOptions^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelSessionOptions^>(info.This())) {
        return;
      }

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

      try {

        unsigned int winRtValue = static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelSessionOptions^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::LearningModelSessionOptions^>(info.This())) {
        return;
      }

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

      try {

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

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


    private:
      ::Windows::AI::MachineLearning::LearningModelSessionOptions^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapLearningModelSessionOptions(::Windows::AI::MachineLearning::LearningModelSessionOptions^ wintRtInstance);
      friend ::Windows::AI::MachineLearning::LearningModelSessionOptions^ UnwrapLearningModelSessionOptions(Local<Value> value);
  };

  Persistent<FunctionTemplate> LearningModelSessionOptions::s_constructorTemplate;

  v8::Local<v8::Value> WrapLearningModelSessionOptions(::Windows::AI::MachineLearning::LearningModelSessionOptions^ 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>(LearningModelSessionOptions::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::AI::MachineLearning::LearningModelSessionOptions^ UnwrapLearningModelSessionOptions(Local<Value> value) {
     return LearningModelSessionOptions::Unwrap<LearningModelSessionOptions>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitLearningModelSessionOptions(Local<Object> exports) {
    LearningModelSessionOptions::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("description").ToLocalChecked(), DescriptionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isRequired").ToLocalChecked(), IsRequiredGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("name").ToLocalChecked(), NameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("keyKind").ToLocalChecked(), KeyKindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("valueDescriptor").ToLocalChecked(), ValueDescriptorGetter);

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



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

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

    private:

      MapFeatureDescriptor(::Windows::AI::MachineLearning::MapFeatureDescriptor^ 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::AI::MachineLearning::MapFeatureDescriptor^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::MapFeatureDescriptor^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::MapFeatureDescriptor^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::MapFeatureDescriptor^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::MapFeatureDescriptor^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::MapFeatureDescriptor^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::MapFeatureDescriptor^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::AI::MachineLearning::ILearningModelFeatureDescriptor^ result = wrapper->_instance->ValueDescriptor;
        info.GetReturnValue().Set(WrapILearningModelFeatureDescriptor(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::AI::MachineLearning::MapFeatureDescriptor^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMapFeatureDescriptor(::Windows::AI::MachineLearning::MapFeatureDescriptor^ wintRtInstance);
      friend ::Windows::AI::MachineLearning::MapFeatureDescriptor^ UnwrapMapFeatureDescriptor(Local<Value> value);
  };

  Persistent<FunctionTemplate> MapFeatureDescriptor::s_constructorTemplate;

  v8::Local<v8::Value> WrapMapFeatureDescriptor(::Windows::AI::MachineLearning::MapFeatureDescriptor^ 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>(MapFeatureDescriptor::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::AI::MachineLearning::MapFeatureDescriptor^ UnwrapMapFeatureDescriptor(Local<Value> value) {
     return MapFeatureDescriptor::Unwrap<MapFeatureDescriptor>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMapFeatureDescriptor(Local<Object> exports) {
    MapFeatureDescriptor::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("description").ToLocalChecked(), DescriptionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isRequired").ToLocalChecked(), IsRequiredGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("name").ToLocalChecked(), NameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("elementDescriptor").ToLocalChecked(), ElementDescriptorGetter);

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



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

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

    private:

      SequenceFeatureDescriptor(::Windows::AI::MachineLearning::SequenceFeatureDescriptor^ 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::AI::MachineLearning::SequenceFeatureDescriptor^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::SequenceFeatureDescriptor^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::SequenceFeatureDescriptor^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::SequenceFeatureDescriptor^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::SequenceFeatureDescriptor^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::SequenceFeatureDescriptor^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::AI::MachineLearning::ILearningModelFeatureDescriptor^ result = wrapper->_instance->ElementDescriptor;
        info.GetReturnValue().Set(WrapILearningModelFeatureDescriptor(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::AI::MachineLearning::SequenceFeatureDescriptor^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapSequenceFeatureDescriptor(::Windows::AI::MachineLearning::SequenceFeatureDescriptor^ wintRtInstance);
      friend ::Windows::AI::MachineLearning::SequenceFeatureDescriptor^ UnwrapSequenceFeatureDescriptor(Local<Value> value);
  };

  Persistent<FunctionTemplate> SequenceFeatureDescriptor::s_constructorTemplate;

  v8::Local<v8::Value> WrapSequenceFeatureDescriptor(::Windows::AI::MachineLearning::SequenceFeatureDescriptor^ 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>(SequenceFeatureDescriptor::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::AI::MachineLearning::SequenceFeatureDescriptor^ UnwrapSequenceFeatureDescriptor(Local<Value> value) {
     return SequenceFeatureDescriptor::Unwrap<SequenceFeatureDescriptor>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitSequenceFeatureDescriptor(Local<Object> exports) {
    SequenceFeatureDescriptor::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getAsVectorView", GetAsVectorView);
            Nan::SetPrototypeMethod(localRef, "createReference", CreateReference);
            Nan::SetPrototypeMethod(localRef, "close", Close);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("shape").ToLocalChecked(), ShapeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("tensorKind").ToLocalChecked(), TensorKindGetter);

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

        Nan::SetMethod(constructor, "createFromShapeArrayAndDataArray", CreateFromShapeArrayAndDataArray);
        Nan::SetMethod(constructor, "createFromBuffer", CreateFromBuffer);
        Nan::SetMethod(constructor, "create", Create);
        Nan::SetMethod(constructor, "createFromArray", CreateFromArray);
        Nan::SetMethod(constructor, "createFromIterable", CreateFromIterable);


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

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

    private:

      TensorBoolean(::Windows::AI::MachineLearning::TensorBoolean^ 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::AI::MachineLearning::TensorBoolean^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorBoolean^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<bool>^ result;
          result = wrapper->_instance->GetAsVectorView();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<bool>::CreateVectorViewWrapper(result, 
            [](bool val) -> Local<Value> {
              return Nan::New<Boolean>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsBoolean();
            },
            [](Local<Value> value) -> bool {
              return Nan::To<bool>(value).FromMaybe(false);
            }
          ));
          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 CreateReference(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorBoolean^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::IMemoryBufferReference^ result;
          result = wrapper->_instance->CreateReference();
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "IMemoryBufferReference", 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 Close(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorBoolean^>(info.This())) {
        return;
      }

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

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

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<bool>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Platform::Array<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Platform::Array<bool>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<bool>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<bool>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsBoolean();
                 },
                 [](Local<Value> value) -> bool {
                   return Nan::To<bool>(value).FromMaybe(false);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<bool>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorBoolean^ result;
          result = ::Windows::AI::MachineLearning::TensorBoolean::CreateFromShapeArrayAndDataArray(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorBoolean(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 CreateFromBuffer(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<__int64>^>(info[0]) || info[0]->IsArray())
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IBuffer^>(info[1]))
      {
        try
        {
          ::Platform::Array<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Storage::Streams::IBuffer^ arg1 = dynamic_cast<::Windows::Storage::Streams::IBuffer^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          ::Windows::AI::MachineLearning::TensorBoolean^ result;
          result = ::Windows::AI::MachineLearning::TensorBoolean::CreateFromBuffer(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorBoolean(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::AI::MachineLearning::TensorBoolean^ result;
          result = ::Windows::AI::MachineLearning::TensorBoolean::Create();
          info.GetReturnValue().Set(WrapTensorBoolean(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          ::Windows::AI::MachineLearning::TensorBoolean^ result;
          result = ::Windows::AI::MachineLearning::TensorBoolean::Create(arg0);
          info.GetReturnValue().Set(WrapTensorBoolean(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 CreateFromArray(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<bool>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Platform::Array<bool>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<bool>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<bool>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsBoolean();
                 },
                 [](Local<Value> value) -> bool {
                   return Nan::To<bool>(value).FromMaybe(false);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<bool>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorBoolean^ result;
          result = ::Windows::AI::MachineLearning::TensorBoolean::CreateFromArray(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorBoolean(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 CreateFromIterable(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<bool>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Foundation::Collections::IIterable<bool>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<bool>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<bool>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsBoolean();
                 },
                 [](Local<Value> value) -> bool {
                   return Nan::To<bool>(value).FromMaybe(false);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<bool>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorBoolean^ result;
          result = ::Windows::AI::MachineLearning::TensorBoolean::CreateFromIterable(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorBoolean(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 KindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorBoolean^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorBoolean^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<__int64>^ result = wrapper->_instance->Shape;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<__int64>::CreateVectorViewWrapper(result, 
            [](__int64 val) -> Local<Value> {
              return Nan::New<Number>(static_cast<double>(val));
            },
            [](Local<Value> value) -> bool {
              return value->IsNumber();
            },
            [](Local<Value> value) -> __int64 {
              return Nan::To<int64_t>(value).FromMaybe(0);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TensorKindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorBoolean^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::AI::MachineLearning::TensorBoolean^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapTensorBoolean(::Windows::AI::MachineLearning::TensorBoolean^ wintRtInstance);
      friend ::Windows::AI::MachineLearning::TensorBoolean^ UnwrapTensorBoolean(Local<Value> value);
  };

  Persistent<FunctionTemplate> TensorBoolean::s_constructorTemplate;

  v8::Local<v8::Value> WrapTensorBoolean(::Windows::AI::MachineLearning::TensorBoolean^ 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>(TensorBoolean::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::AI::MachineLearning::TensorBoolean^ UnwrapTensorBoolean(Local<Value> value) {
     return TensorBoolean::Unwrap<TensorBoolean>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitTensorBoolean(Local<Object> exports) {
    TensorBoolean::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getAsVectorView", GetAsVectorView);
            Nan::SetPrototypeMethod(localRef, "createReference", CreateReference);
            Nan::SetPrototypeMethod(localRef, "close", Close);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("shape").ToLocalChecked(), ShapeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("tensorKind").ToLocalChecked(), TensorKindGetter);

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

        Nan::SetMethod(constructor, "createFromShapeArrayAndDataArray", CreateFromShapeArrayAndDataArray);
        Nan::SetMethod(constructor, "createFromBuffer", CreateFromBuffer);
        Nan::SetMethod(constructor, "create", Create);
        Nan::SetMethod(constructor, "createFromArray", CreateFromArray);
        Nan::SetMethod(constructor, "createFromIterable", CreateFromIterable);


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

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

    private:

      TensorDouble(::Windows::AI::MachineLearning::TensorDouble^ 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::AI::MachineLearning::TensorDouble^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorDouble^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<double>^ result;
          result = wrapper->_instance->GetAsVectorView();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<double>::CreateVectorViewWrapper(result, 
            [](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);
            }
          ));
          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 CreateReference(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorDouble^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::IMemoryBufferReference^ result;
          result = wrapper->_instance->CreateReference();
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "IMemoryBufferReference", 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 Close(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorDouble^>(info.This())) {
        return;
      }

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

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

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<double>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Platform::Array<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Platform::Array<double>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<double>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<double>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> double {
                   return Nan::To<double>(value).FromMaybe(0.0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<double>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorDouble^ result;
          result = ::Windows::AI::MachineLearning::TensorDouble::CreateFromShapeArrayAndDataArray(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorDouble(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 CreateFromBuffer(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<__int64>^>(info[0]) || info[0]->IsArray())
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IBuffer^>(info[1]))
      {
        try
        {
          ::Platform::Array<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Storage::Streams::IBuffer^ arg1 = dynamic_cast<::Windows::Storage::Streams::IBuffer^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          ::Windows::AI::MachineLearning::TensorDouble^ result;
          result = ::Windows::AI::MachineLearning::TensorDouble::CreateFromBuffer(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorDouble(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::AI::MachineLearning::TensorDouble^ result;
          result = ::Windows::AI::MachineLearning::TensorDouble::Create();
          info.GetReturnValue().Set(WrapTensorDouble(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          ::Windows::AI::MachineLearning::TensorDouble^ result;
          result = ::Windows::AI::MachineLearning::TensorDouble::Create(arg0);
          info.GetReturnValue().Set(WrapTensorDouble(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 CreateFromArray(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<double>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Platform::Array<double>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<double>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<double>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> double {
                   return Nan::To<double>(value).FromMaybe(0.0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<double>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorDouble^ result;
          result = ::Windows::AI::MachineLearning::TensorDouble::CreateFromArray(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorDouble(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 CreateFromIterable(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<double>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Foundation::Collections::IIterable<double>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<double>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<double>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> double {
                   return Nan::To<double>(value).FromMaybe(0.0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<double>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorDouble^ result;
          result = ::Windows::AI::MachineLearning::TensorDouble::CreateFromIterable(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorDouble(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 KindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorDouble^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorDouble^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<__int64>^ result = wrapper->_instance->Shape;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<__int64>::CreateVectorViewWrapper(result, 
            [](__int64 val) -> Local<Value> {
              return Nan::New<Number>(static_cast<double>(val));
            },
            [](Local<Value> value) -> bool {
              return value->IsNumber();
            },
            [](Local<Value> value) -> __int64 {
              return Nan::To<int64_t>(value).FromMaybe(0);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TensorKindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorDouble^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::AI::MachineLearning::TensorDouble^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapTensorDouble(::Windows::AI::MachineLearning::TensorDouble^ wintRtInstance);
      friend ::Windows::AI::MachineLearning::TensorDouble^ UnwrapTensorDouble(Local<Value> value);
  };

  Persistent<FunctionTemplate> TensorDouble::s_constructorTemplate;

  v8::Local<v8::Value> WrapTensorDouble(::Windows::AI::MachineLearning::TensorDouble^ 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>(TensorDouble::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::AI::MachineLearning::TensorDouble^ UnwrapTensorDouble(Local<Value> value) {
     return TensorDouble::Unwrap<TensorDouble>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitTensorDouble(Local<Object> exports) {
    TensorDouble::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("description").ToLocalChecked(), DescriptionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isRequired").ToLocalChecked(), IsRequiredGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("name").ToLocalChecked(), NameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("shape").ToLocalChecked(), ShapeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("tensorKind").ToLocalChecked(), TensorKindGetter);

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



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

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

    private:

      TensorFeatureDescriptor(::Windows::AI::MachineLearning::TensorFeatureDescriptor^ 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::AI::MachineLearning::TensorFeatureDescriptor^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorFeatureDescriptor^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorFeatureDescriptor^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorFeatureDescriptor^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorFeatureDescriptor^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorFeatureDescriptor^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<__int64>^ result = wrapper->_instance->Shape;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<__int64>::CreateVectorViewWrapper(result, 
            [](__int64 val) -> Local<Value> {
              return Nan::New<Number>(static_cast<double>(val));
            },
            [](Local<Value> value) -> bool {
              return value->IsNumber();
            },
            [](Local<Value> value) -> __int64 {
              return Nan::To<int64_t>(value).FromMaybe(0);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TensorKindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorFeatureDescriptor^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::AI::MachineLearning::TensorFeatureDescriptor^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapTensorFeatureDescriptor(::Windows::AI::MachineLearning::TensorFeatureDescriptor^ wintRtInstance);
      friend ::Windows::AI::MachineLearning::TensorFeatureDescriptor^ UnwrapTensorFeatureDescriptor(Local<Value> value);
  };

  Persistent<FunctionTemplate> TensorFeatureDescriptor::s_constructorTemplate;

  v8::Local<v8::Value> WrapTensorFeatureDescriptor(::Windows::AI::MachineLearning::TensorFeatureDescriptor^ 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>(TensorFeatureDescriptor::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::AI::MachineLearning::TensorFeatureDescriptor^ UnwrapTensorFeatureDescriptor(Local<Value> value) {
     return TensorFeatureDescriptor::Unwrap<TensorFeatureDescriptor>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitTensorFeatureDescriptor(Local<Object> exports) {
    TensorFeatureDescriptor::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getAsVectorView", GetAsVectorView);
            Nan::SetPrototypeMethod(localRef, "createReference", CreateReference);
            Nan::SetPrototypeMethod(localRef, "close", Close);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("shape").ToLocalChecked(), ShapeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("tensorKind").ToLocalChecked(), TensorKindGetter);

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

        Nan::SetMethod(constructor, "createFromShapeArrayAndDataArray", CreateFromShapeArrayAndDataArray);
        Nan::SetMethod(constructor, "createFromBuffer", CreateFromBuffer);
        Nan::SetMethod(constructor, "create", Create);
        Nan::SetMethod(constructor, "createFromArray", CreateFromArray);
        Nan::SetMethod(constructor, "createFromIterable", CreateFromIterable);


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

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

    private:

      TensorFloat(::Windows::AI::MachineLearning::TensorFloat^ 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::AI::MachineLearning::TensorFloat^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorFloat^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<float>^ result;
          result = wrapper->_instance->GetAsVectorView();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<float>::CreateVectorViewWrapper(result, 
            [](float val) -> Local<Value> {
              return Nan::New<Number>(static_cast<double>(val));
            },
            [](Local<Value> value) -> bool {
              return value->IsNumber();
            },
            [](Local<Value> value) -> float {
              return static_cast<float>(Nan::To<double>(value).FromMaybe(0.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 CreateReference(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorFloat^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::IMemoryBufferReference^ result;
          result = wrapper->_instance->CreateReference();
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "IMemoryBufferReference", 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 Close(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorFloat^>(info.This())) {
        return;
      }

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

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

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<float>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Platform::Array<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Platform::Array<float>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<float>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<float>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> float {
                   return static_cast<float>(Nan::To<double>(value).FromMaybe(0.0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<float>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorFloat^ result;
          result = ::Windows::AI::MachineLearning::TensorFloat::CreateFromShapeArrayAndDataArray(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorFloat(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 CreateFromBuffer(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<__int64>^>(info[0]) || info[0]->IsArray())
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IBuffer^>(info[1]))
      {
        try
        {
          ::Platform::Array<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Storage::Streams::IBuffer^ arg1 = dynamic_cast<::Windows::Storage::Streams::IBuffer^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          ::Windows::AI::MachineLearning::TensorFloat^ result;
          result = ::Windows::AI::MachineLearning::TensorFloat::CreateFromBuffer(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorFloat(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::AI::MachineLearning::TensorFloat^ result;
          result = ::Windows::AI::MachineLearning::TensorFloat::Create();
          info.GetReturnValue().Set(WrapTensorFloat(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          ::Windows::AI::MachineLearning::TensorFloat^ result;
          result = ::Windows::AI::MachineLearning::TensorFloat::Create(arg0);
          info.GetReturnValue().Set(WrapTensorFloat(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 CreateFromArray(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<float>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Platform::Array<float>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<float>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<float>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> float {
                   return static_cast<float>(Nan::To<double>(value).FromMaybe(0.0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<float>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorFloat^ result;
          result = ::Windows::AI::MachineLearning::TensorFloat::CreateFromArray(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorFloat(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 CreateFromIterable(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<float>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Foundation::Collections::IIterable<float>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<float>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<float>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> float {
                   return static_cast<float>(Nan::To<double>(value).FromMaybe(0.0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<float>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorFloat^ result;
          result = ::Windows::AI::MachineLearning::TensorFloat::CreateFromIterable(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorFloat(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 KindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorFloat^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorFloat^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<__int64>^ result = wrapper->_instance->Shape;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<__int64>::CreateVectorViewWrapper(result, 
            [](__int64 val) -> Local<Value> {
              return Nan::New<Number>(static_cast<double>(val));
            },
            [](Local<Value> value) -> bool {
              return value->IsNumber();
            },
            [](Local<Value> value) -> __int64 {
              return Nan::To<int64_t>(value).FromMaybe(0);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TensorKindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorFloat^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::AI::MachineLearning::TensorFloat^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapTensorFloat(::Windows::AI::MachineLearning::TensorFloat^ wintRtInstance);
      friend ::Windows::AI::MachineLearning::TensorFloat^ UnwrapTensorFloat(Local<Value> value);
  };

  Persistent<FunctionTemplate> TensorFloat::s_constructorTemplate;

  v8::Local<v8::Value> WrapTensorFloat(::Windows::AI::MachineLearning::TensorFloat^ 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>(TensorFloat::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::AI::MachineLearning::TensorFloat^ UnwrapTensorFloat(Local<Value> value) {
     return TensorFloat::Unwrap<TensorFloat>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitTensorFloat(Local<Object> exports) {
    TensorFloat::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getAsVectorView", GetAsVectorView);
            Nan::SetPrototypeMethod(localRef, "createReference", CreateReference);
            Nan::SetPrototypeMethod(localRef, "close", Close);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("shape").ToLocalChecked(), ShapeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("tensorKind").ToLocalChecked(), TensorKindGetter);

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

        Nan::SetMethod(constructor, "createFromShapeArrayAndDataArray", CreateFromShapeArrayAndDataArray);
        Nan::SetMethod(constructor, "createFromBuffer", CreateFromBuffer);
        Nan::SetMethod(constructor, "create", Create);
        Nan::SetMethod(constructor, "createFromArray", CreateFromArray);
        Nan::SetMethod(constructor, "createFromIterable", CreateFromIterable);


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

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

    private:

      TensorFloat16Bit(::Windows::AI::MachineLearning::TensorFloat16Bit^ 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::AI::MachineLearning::TensorFloat16Bit^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorFloat16Bit^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<float>^ result;
          result = wrapper->_instance->GetAsVectorView();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<float>::CreateVectorViewWrapper(result, 
            [](float val) -> Local<Value> {
              return Nan::New<Number>(static_cast<double>(val));
            },
            [](Local<Value> value) -> bool {
              return value->IsNumber();
            },
            [](Local<Value> value) -> float {
              return static_cast<float>(Nan::To<double>(value).FromMaybe(0.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 CreateReference(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorFloat16Bit^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::IMemoryBufferReference^ result;
          result = wrapper->_instance->CreateReference();
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "IMemoryBufferReference", 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 Close(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorFloat16Bit^>(info.This())) {
        return;
      }

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

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

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<float>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Platform::Array<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Platform::Array<float>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<float>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<float>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> float {
                   return static_cast<float>(Nan::To<double>(value).FromMaybe(0.0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<float>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorFloat16Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorFloat16Bit::CreateFromShapeArrayAndDataArray(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorFloat16Bit(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 CreateFromBuffer(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<__int64>^>(info[0]) || info[0]->IsArray())
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IBuffer^>(info[1]))
      {
        try
        {
          ::Platform::Array<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Storage::Streams::IBuffer^ arg1 = dynamic_cast<::Windows::Storage::Streams::IBuffer^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          ::Windows::AI::MachineLearning::TensorFloat16Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorFloat16Bit::CreateFromBuffer(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorFloat16Bit(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::AI::MachineLearning::TensorFloat16Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorFloat16Bit::Create();
          info.GetReturnValue().Set(WrapTensorFloat16Bit(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          ::Windows::AI::MachineLearning::TensorFloat16Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorFloat16Bit::Create(arg0);
          info.GetReturnValue().Set(WrapTensorFloat16Bit(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 CreateFromArray(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<float>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Platform::Array<float>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<float>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<float>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> float {
                   return static_cast<float>(Nan::To<double>(value).FromMaybe(0.0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<float>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorFloat16Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorFloat16Bit::CreateFromArray(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorFloat16Bit(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 CreateFromIterable(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<float>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Foundation::Collections::IIterable<float>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<float>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<float>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> float {
                   return static_cast<float>(Nan::To<double>(value).FromMaybe(0.0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<float>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorFloat16Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorFloat16Bit::CreateFromIterable(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorFloat16Bit(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 KindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorFloat16Bit^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorFloat16Bit^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<__int64>^ result = wrapper->_instance->Shape;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<__int64>::CreateVectorViewWrapper(result, 
            [](__int64 val) -> Local<Value> {
              return Nan::New<Number>(static_cast<double>(val));
            },
            [](Local<Value> value) -> bool {
              return value->IsNumber();
            },
            [](Local<Value> value) -> __int64 {
              return Nan::To<int64_t>(value).FromMaybe(0);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TensorKindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorFloat16Bit^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::AI::MachineLearning::TensorFloat16Bit^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapTensorFloat16Bit(::Windows::AI::MachineLearning::TensorFloat16Bit^ wintRtInstance);
      friend ::Windows::AI::MachineLearning::TensorFloat16Bit^ UnwrapTensorFloat16Bit(Local<Value> value);
  };

  Persistent<FunctionTemplate> TensorFloat16Bit::s_constructorTemplate;

  v8::Local<v8::Value> WrapTensorFloat16Bit(::Windows::AI::MachineLearning::TensorFloat16Bit^ 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>(TensorFloat16Bit::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::AI::MachineLearning::TensorFloat16Bit^ UnwrapTensorFloat16Bit(Local<Value> value) {
     return TensorFloat16Bit::Unwrap<TensorFloat16Bit>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitTensorFloat16Bit(Local<Object> exports) {
    TensorFloat16Bit::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getAsVectorView", GetAsVectorView);
            Nan::SetPrototypeMethod(localRef, "createReference", CreateReference);
            Nan::SetPrototypeMethod(localRef, "close", Close);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("shape").ToLocalChecked(), ShapeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("tensorKind").ToLocalChecked(), TensorKindGetter);

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

        Nan::SetMethod(constructor, "createFromShapeArrayAndDataArray", CreateFromShapeArrayAndDataArray);
        Nan::SetMethod(constructor, "createFromBuffer", CreateFromBuffer);
        Nan::SetMethod(constructor, "create", Create);
        Nan::SetMethod(constructor, "createFromArray", CreateFromArray);
        Nan::SetMethod(constructor, "createFromIterable", CreateFromIterable);


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

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

    private:

      TensorInt16Bit(::Windows::AI::MachineLearning::TensorInt16Bit^ 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::AI::MachineLearning::TensorInt16Bit^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorInt16Bit^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<short>^ result;
          result = wrapper->_instance->GetAsVectorView();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<short>::CreateVectorViewWrapper(result, 
            [](short val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsInt32();
            },
            [](Local<Value> value) -> short {
              return static_cast<short>(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 CreateReference(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorInt16Bit^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::IMemoryBufferReference^ result;
          result = wrapper->_instance->CreateReference();
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "IMemoryBufferReference", 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 Close(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorInt16Bit^>(info.This())) {
        return;
      }

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

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

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<short>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Platform::Array<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Platform::Array<short>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<short>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<short>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsInt32();
                 },
                 [](Local<Value> value) -> short {
                   return static_cast<short>(Nan::To<int32_t>(value).FromMaybe(0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<short>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorInt16Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorInt16Bit::CreateFromShapeArrayAndDataArray(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorInt16Bit(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 CreateFromBuffer(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<__int64>^>(info[0]) || info[0]->IsArray())
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IBuffer^>(info[1]))
      {
        try
        {
          ::Platform::Array<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Storage::Streams::IBuffer^ arg1 = dynamic_cast<::Windows::Storage::Streams::IBuffer^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          ::Windows::AI::MachineLearning::TensorInt16Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorInt16Bit::CreateFromBuffer(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorInt16Bit(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::AI::MachineLearning::TensorInt16Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorInt16Bit::Create();
          info.GetReturnValue().Set(WrapTensorInt16Bit(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          ::Windows::AI::MachineLearning::TensorInt16Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorInt16Bit::Create(arg0);
          info.GetReturnValue().Set(WrapTensorInt16Bit(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 CreateFromArray(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<short>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Platform::Array<short>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<short>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<short>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsInt32();
                 },
                 [](Local<Value> value) -> short {
                   return static_cast<short>(Nan::To<int32_t>(value).FromMaybe(0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<short>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorInt16Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorInt16Bit::CreateFromArray(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorInt16Bit(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 CreateFromIterable(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<short>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Foundation::Collections::IIterable<short>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<short>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<short>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsInt32();
                 },
                 [](Local<Value> value) -> short {
                   return static_cast<short>(Nan::To<int32_t>(value).FromMaybe(0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<short>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorInt16Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorInt16Bit::CreateFromIterable(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorInt16Bit(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 KindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorInt16Bit^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorInt16Bit^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<__int64>^ result = wrapper->_instance->Shape;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<__int64>::CreateVectorViewWrapper(result, 
            [](__int64 val) -> Local<Value> {
              return Nan::New<Number>(static_cast<double>(val));
            },
            [](Local<Value> value) -> bool {
              return value->IsNumber();
            },
            [](Local<Value> value) -> __int64 {
              return Nan::To<int64_t>(value).FromMaybe(0);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TensorKindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorInt16Bit^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::AI::MachineLearning::TensorInt16Bit^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapTensorInt16Bit(::Windows::AI::MachineLearning::TensorInt16Bit^ wintRtInstance);
      friend ::Windows::AI::MachineLearning::TensorInt16Bit^ UnwrapTensorInt16Bit(Local<Value> value);
  };

  Persistent<FunctionTemplate> TensorInt16Bit::s_constructorTemplate;

  v8::Local<v8::Value> WrapTensorInt16Bit(::Windows::AI::MachineLearning::TensorInt16Bit^ 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>(TensorInt16Bit::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::AI::MachineLearning::TensorInt16Bit^ UnwrapTensorInt16Bit(Local<Value> value) {
     return TensorInt16Bit::Unwrap<TensorInt16Bit>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitTensorInt16Bit(Local<Object> exports) {
    TensorInt16Bit::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getAsVectorView", GetAsVectorView);
            Nan::SetPrototypeMethod(localRef, "createReference", CreateReference);
            Nan::SetPrototypeMethod(localRef, "close", Close);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("shape").ToLocalChecked(), ShapeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("tensorKind").ToLocalChecked(), TensorKindGetter);

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

        Nan::SetMethod(constructor, "createFromShapeArrayAndDataArray", CreateFromShapeArrayAndDataArray);
        Nan::SetMethod(constructor, "createFromBuffer", CreateFromBuffer);
        Nan::SetMethod(constructor, "create", Create);
        Nan::SetMethod(constructor, "createFromArray", CreateFromArray);
        Nan::SetMethod(constructor, "createFromIterable", CreateFromIterable);


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

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

    private:

      TensorInt32Bit(::Windows::AI::MachineLearning::TensorInt32Bit^ 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::AI::MachineLearning::TensorInt32Bit^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorInt32Bit^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<int>^ result;
          result = wrapper->_instance->GetAsVectorView();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<int>::CreateVectorViewWrapper(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 CreateReference(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorInt32Bit^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::IMemoryBufferReference^ result;
          result = wrapper->_instance->CreateReference();
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "IMemoryBufferReference", 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 Close(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorInt32Bit^>(info.This())) {
        return;
      }

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

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

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<int>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Platform::Array<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Platform::Array<int>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<int>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<int>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsInt32();
                 },
                 [](Local<Value> value) -> int {
                   return static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<int>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorInt32Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorInt32Bit::CreateFromShapeArrayAndDataArray(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorInt32Bit(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 CreateFromBuffer(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<__int64>^>(info[0]) || info[0]->IsArray())
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IBuffer^>(info[1]))
      {
        try
        {
          ::Platform::Array<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Storage::Streams::IBuffer^ arg1 = dynamic_cast<::Windows::Storage::Streams::IBuffer^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          ::Windows::AI::MachineLearning::TensorInt32Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorInt32Bit::CreateFromBuffer(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorInt32Bit(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::AI::MachineLearning::TensorInt32Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorInt32Bit::Create();
          info.GetReturnValue().Set(WrapTensorInt32Bit(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          ::Windows::AI::MachineLearning::TensorInt32Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorInt32Bit::Create(arg0);
          info.GetReturnValue().Set(WrapTensorInt32Bit(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 CreateFromArray(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<int>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Platform::Array<int>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<int>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<int>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsInt32();
                 },
                 [](Local<Value> value) -> int {
                   return static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<int>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorInt32Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorInt32Bit::CreateFromArray(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorInt32Bit(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 CreateFromIterable(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<int>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Foundation::Collections::IIterable<int>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<int>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<int>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsInt32();
                 },
                 [](Local<Value> value) -> int {
                   return static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<int>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorInt32Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorInt32Bit::CreateFromIterable(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorInt32Bit(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 KindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorInt32Bit^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorInt32Bit^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<__int64>^ result = wrapper->_instance->Shape;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<__int64>::CreateVectorViewWrapper(result, 
            [](__int64 val) -> Local<Value> {
              return Nan::New<Number>(static_cast<double>(val));
            },
            [](Local<Value> value) -> bool {
              return value->IsNumber();
            },
            [](Local<Value> value) -> __int64 {
              return Nan::To<int64_t>(value).FromMaybe(0);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TensorKindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorInt32Bit^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::AI::MachineLearning::TensorInt32Bit^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapTensorInt32Bit(::Windows::AI::MachineLearning::TensorInt32Bit^ wintRtInstance);
      friend ::Windows::AI::MachineLearning::TensorInt32Bit^ UnwrapTensorInt32Bit(Local<Value> value);
  };

  Persistent<FunctionTemplate> TensorInt32Bit::s_constructorTemplate;

  v8::Local<v8::Value> WrapTensorInt32Bit(::Windows::AI::MachineLearning::TensorInt32Bit^ 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>(TensorInt32Bit::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::AI::MachineLearning::TensorInt32Bit^ UnwrapTensorInt32Bit(Local<Value> value) {
     return TensorInt32Bit::Unwrap<TensorInt32Bit>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitTensorInt32Bit(Local<Object> exports) {
    TensorInt32Bit::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getAsVectorView", GetAsVectorView);
            Nan::SetPrototypeMethod(localRef, "createReference", CreateReference);
            Nan::SetPrototypeMethod(localRef, "close", Close);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("shape").ToLocalChecked(), ShapeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("tensorKind").ToLocalChecked(), TensorKindGetter);

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

        Nan::SetMethod(constructor, "createFromShapeArrayAndDataArray", CreateFromShapeArrayAndDataArray);
        Nan::SetMethod(constructor, "createFromBuffer", CreateFromBuffer);
        Nan::SetMethod(constructor, "create", Create);
        Nan::SetMethod(constructor, "createFromArray", CreateFromArray);
        Nan::SetMethod(constructor, "createFromIterable", CreateFromIterable);


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

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

    private:

      TensorInt64Bit(::Windows::AI::MachineLearning::TensorInt64Bit^ 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::AI::MachineLearning::TensorInt64Bit^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorInt64Bit^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<__int64>^ result;
          result = wrapper->_instance->GetAsVectorView();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<__int64>::CreateVectorViewWrapper(result, 
            [](__int64 val) -> Local<Value> {
              return Nan::New<Number>(static_cast<double>(val));
            },
            [](Local<Value> value) -> bool {
              return value->IsNumber();
            },
            [](Local<Value> value) -> __int64 {
              return Nan::To<int64_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 CreateReference(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorInt64Bit^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::IMemoryBufferReference^ result;
          result = wrapper->_instance->CreateReference();
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "IMemoryBufferReference", 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 Close(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorInt64Bit^>(info.This())) {
        return;
      }

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

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

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<__int64>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Platform::Array<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Platform::Array<__int64>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorInt64Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorInt64Bit::CreateFromShapeArrayAndDataArray(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorInt64Bit(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 CreateFromBuffer(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<__int64>^>(info[0]) || info[0]->IsArray())
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IBuffer^>(info[1]))
      {
        try
        {
          ::Platform::Array<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Storage::Streams::IBuffer^ arg1 = dynamic_cast<::Windows::Storage::Streams::IBuffer^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          ::Windows::AI::MachineLearning::TensorInt64Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorInt64Bit::CreateFromBuffer(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorInt64Bit(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::AI::MachineLearning::TensorInt64Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorInt64Bit::Create();
          info.GetReturnValue().Set(WrapTensorInt64Bit(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          ::Windows::AI::MachineLearning::TensorInt64Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorInt64Bit::Create(arg0);
          info.GetReturnValue().Set(WrapTensorInt64Bit(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 CreateFromArray(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<__int64>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Platform::Array<__int64>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorInt64Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorInt64Bit::CreateFromArray(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorInt64Bit(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 CreateFromIterable(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorInt64Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorInt64Bit::CreateFromIterable(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorInt64Bit(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 KindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorInt64Bit^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorInt64Bit^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<__int64>^ result = wrapper->_instance->Shape;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<__int64>::CreateVectorViewWrapper(result, 
            [](__int64 val) -> Local<Value> {
              return Nan::New<Number>(static_cast<double>(val));
            },
            [](Local<Value> value) -> bool {
              return value->IsNumber();
            },
            [](Local<Value> value) -> __int64 {
              return Nan::To<int64_t>(value).FromMaybe(0);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TensorKindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorInt64Bit^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::AI::MachineLearning::TensorInt64Bit^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapTensorInt64Bit(::Windows::AI::MachineLearning::TensorInt64Bit^ wintRtInstance);
      friend ::Windows::AI::MachineLearning::TensorInt64Bit^ UnwrapTensorInt64Bit(Local<Value> value);
  };

  Persistent<FunctionTemplate> TensorInt64Bit::s_constructorTemplate;

  v8::Local<v8::Value> WrapTensorInt64Bit(::Windows::AI::MachineLearning::TensorInt64Bit^ 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>(TensorInt64Bit::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::AI::MachineLearning::TensorInt64Bit^ UnwrapTensorInt64Bit(Local<Value> value) {
     return TensorInt64Bit::Unwrap<TensorInt64Bit>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitTensorInt64Bit(Local<Object> exports) {
    TensorInt64Bit::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getAsVectorView", GetAsVectorView);
            Nan::SetPrototypeMethod(localRef, "createReference", CreateReference);
            Nan::SetPrototypeMethod(localRef, "close", Close);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("shape").ToLocalChecked(), ShapeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("tensorKind").ToLocalChecked(), TensorKindGetter);

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

        Nan::SetMethod(constructor, "createFromShapeArrayAndDataArray", CreateFromShapeArrayAndDataArray);
        Nan::SetMethod(constructor, "createFromBuffer", CreateFromBuffer);
        Nan::SetMethod(constructor, "create", Create);
        Nan::SetMethod(constructor, "createFromArray", CreateFromArray);
        Nan::SetMethod(constructor, "createFromIterable", CreateFromIterable);


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

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

    private:

      TensorInt8Bit(::Windows::AI::MachineLearning::TensorInt8Bit^ 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::AI::MachineLearning::TensorInt8Bit^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorInt8Bit^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<unsigned char>^ result;
          result = wrapper->_instance->GetAsVectorView();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned char>::CreateVectorViewWrapper(result, 
            [](unsigned char val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsInt32();
            },
            [](Local<Value> value) -> unsigned char {
              return static_cast<unsigned char>(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 CreateReference(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorInt8Bit^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::IMemoryBufferReference^ result;
          result = wrapper->_instance->CreateReference();
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "IMemoryBufferReference", 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 Close(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorInt8Bit^>(info.This())) {
        return;
      }

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

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

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<unsigned char>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Platform::Array<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Platform::Array<unsigned char>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<unsigned char>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<unsigned char>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsInt32();
                 },
                 [](Local<Value> value) -> unsigned char {
                   return static_cast<unsigned char>(Nan::To<int32_t>(value).FromMaybe(0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<unsigned char>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorInt8Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorInt8Bit::CreateFromShapeArrayAndDataArray(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorInt8Bit(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 CreateFromBuffer(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<__int64>^>(info[0]) || info[0]->IsArray())
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IBuffer^>(info[1]))
      {
        try
        {
          ::Platform::Array<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Storage::Streams::IBuffer^ arg1 = dynamic_cast<::Windows::Storage::Streams::IBuffer^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          ::Windows::AI::MachineLearning::TensorInt8Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorInt8Bit::CreateFromBuffer(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorInt8Bit(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::AI::MachineLearning::TensorInt8Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorInt8Bit::Create();
          info.GetReturnValue().Set(WrapTensorInt8Bit(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          ::Windows::AI::MachineLearning::TensorInt8Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorInt8Bit::Create(arg0);
          info.GetReturnValue().Set(WrapTensorInt8Bit(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 CreateFromArray(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<unsigned char>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Platform::Array<unsigned char>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<unsigned char>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<unsigned char>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsInt32();
                 },
                 [](Local<Value> value) -> unsigned char {
                   return static_cast<unsigned char>(Nan::To<int32_t>(value).FromMaybe(0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<unsigned char>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorInt8Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorInt8Bit::CreateFromArray(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorInt8Bit(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 CreateFromIterable(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<unsigned char>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Foundation::Collections::IIterable<unsigned char>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<unsigned char>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<unsigned char>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsInt32();
                 },
                 [](Local<Value> value) -> unsigned char {
                   return static_cast<unsigned char>(Nan::To<int32_t>(value).FromMaybe(0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<unsigned char>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorInt8Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorInt8Bit::CreateFromIterable(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorInt8Bit(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 KindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorInt8Bit^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorInt8Bit^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<__int64>^ result = wrapper->_instance->Shape;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<__int64>::CreateVectorViewWrapper(result, 
            [](__int64 val) -> Local<Value> {
              return Nan::New<Number>(static_cast<double>(val));
            },
            [](Local<Value> value) -> bool {
              return value->IsNumber();
            },
            [](Local<Value> value) -> __int64 {
              return Nan::To<int64_t>(value).FromMaybe(0);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TensorKindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorInt8Bit^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::AI::MachineLearning::TensorInt8Bit^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapTensorInt8Bit(::Windows::AI::MachineLearning::TensorInt8Bit^ wintRtInstance);
      friend ::Windows::AI::MachineLearning::TensorInt8Bit^ UnwrapTensorInt8Bit(Local<Value> value);
  };

  Persistent<FunctionTemplate> TensorInt8Bit::s_constructorTemplate;

  v8::Local<v8::Value> WrapTensorInt8Bit(::Windows::AI::MachineLearning::TensorInt8Bit^ 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>(TensorInt8Bit::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::AI::MachineLearning::TensorInt8Bit^ UnwrapTensorInt8Bit(Local<Value> value) {
     return TensorInt8Bit::Unwrap<TensorInt8Bit>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitTensorInt8Bit(Local<Object> exports) {
    TensorInt8Bit::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getAsVectorView", GetAsVectorView);
            Nan::SetPrototypeMethod(localRef, "createReference", CreateReference);
            Nan::SetPrototypeMethod(localRef, "close", Close);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("shape").ToLocalChecked(), ShapeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("tensorKind").ToLocalChecked(), TensorKindGetter);

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

        Nan::SetMethod(constructor, "createFromShapeArrayAndDataArray", CreateFromShapeArrayAndDataArray);
        Nan::SetMethod(constructor, "create", Create);
        Nan::SetMethod(constructor, "createFromArray", CreateFromArray);
        Nan::SetMethod(constructor, "createFromIterable", CreateFromIterable);


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

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

    private:

      TensorString(::Windows::AI::MachineLearning::TensorString^ 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::AI::MachineLearning::TensorString^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorString^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Platform::String^>^ result;
          result = wrapper->_instance->GetAsVectorView();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Platform::String^>::CreateVectorViewWrapper(result, 
            [](::Platform::String^ val) -> Local<Value> {
              return NodeRT::Utils::NewString(val->Data());
            },
            [](Local<Value> value) -> bool {
              return value->IsString();
            },
            [](Local<Value> value) -> ::Platform::String^ {
              return ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void CreateReference(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorString^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::IMemoryBufferReference^ result;
          result = wrapper->_instance->CreateReference();
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "IMemoryBufferReference", 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 Close(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorString^>(info.This())) {
        return;
      }

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

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

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<::Platform::String^>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Platform::Array<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Platform::Array<::Platform::String^>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<::Platform::String^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<::Platform::String^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return (!NodeRT::Utils::IsWinRtWrapper(value));
                 },
                 [](Local<Value> value) -> ::Platform::String^ {
                   return ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<::Platform::String^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorString^ result;
          result = ::Windows::AI::MachineLearning::TensorString::CreateFromShapeArrayAndDataArray(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorString(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::AI::MachineLearning::TensorString^ result;
          result = ::Windows::AI::MachineLearning::TensorString::Create();
          info.GetReturnValue().Set(WrapTensorString(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          ::Windows::AI::MachineLearning::TensorString^ result;
          result = ::Windows::AI::MachineLearning::TensorString::Create(arg0);
          info.GetReturnValue().Set(WrapTensorString(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 CreateFromArray(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<::Platform::String^>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Platform::Array<::Platform::String^>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<::Platform::String^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<::Platform::String^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return (!NodeRT::Utils::IsWinRtWrapper(value));
                 },
                 [](Local<Value> value) -> ::Platform::String^ {
                   return ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<::Platform::String^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorString^ result;
          result = ::Windows::AI::MachineLearning::TensorString::CreateFromArray(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorString(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 CreateFromIterable(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Platform::String^>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Foundation::Collections::IIterable<::Platform::String^>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Platform::String^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Platform::String^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return (!NodeRT::Utils::IsWinRtWrapper(value));
                 },
                 [](Local<Value> value) -> ::Platform::String^ {
                   return ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Platform::String^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorString^ result;
          result = ::Windows::AI::MachineLearning::TensorString::CreateFromIterable(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorString(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 KindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorString^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorString^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<__int64>^ result = wrapper->_instance->Shape;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<__int64>::CreateVectorViewWrapper(result, 
            [](__int64 val) -> Local<Value> {
              return Nan::New<Number>(static_cast<double>(val));
            },
            [](Local<Value> value) -> bool {
              return value->IsNumber();
            },
            [](Local<Value> value) -> __int64 {
              return Nan::To<int64_t>(value).FromMaybe(0);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TensorKindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorString^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::AI::MachineLearning::TensorString^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapTensorString(::Windows::AI::MachineLearning::TensorString^ wintRtInstance);
      friend ::Windows::AI::MachineLearning::TensorString^ UnwrapTensorString(Local<Value> value);
  };

  Persistent<FunctionTemplate> TensorString::s_constructorTemplate;

  v8::Local<v8::Value> WrapTensorString(::Windows::AI::MachineLearning::TensorString^ 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>(TensorString::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::AI::MachineLearning::TensorString^ UnwrapTensorString(Local<Value> value) {
     return TensorString::Unwrap<TensorString>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitTensorString(Local<Object> exports) {
    TensorString::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getAsVectorView", GetAsVectorView);
            Nan::SetPrototypeMethod(localRef, "createReference", CreateReference);
            Nan::SetPrototypeMethod(localRef, "close", Close);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("shape").ToLocalChecked(), ShapeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("tensorKind").ToLocalChecked(), TensorKindGetter);

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

        Nan::SetMethod(constructor, "createFromShapeArrayAndDataArray", CreateFromShapeArrayAndDataArray);
        Nan::SetMethod(constructor, "createFromBuffer", CreateFromBuffer);
        Nan::SetMethod(constructor, "create", Create);
        Nan::SetMethod(constructor, "createFromArray", CreateFromArray);
        Nan::SetMethod(constructor, "createFromIterable", CreateFromIterable);


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

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

    private:

      TensorUInt16Bit(::Windows::AI::MachineLearning::TensorUInt16Bit^ 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::AI::MachineLearning::TensorUInt16Bit^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorUInt16Bit^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<unsigned short>^ result;
          result = wrapper->_instance->GetAsVectorView();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned short>::CreateVectorViewWrapper(result, 
            [](unsigned short val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsInt32();
            },
            [](Local<Value> value) -> unsigned short {
              return static_cast<unsigned short>(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 CreateReference(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorUInt16Bit^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::IMemoryBufferReference^ result;
          result = wrapper->_instance->CreateReference();
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "IMemoryBufferReference", 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 Close(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorUInt16Bit^>(info.This())) {
        return;
      }

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

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

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<unsigned short>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Platform::Array<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Platform::Array<unsigned short>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<unsigned short>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<unsigned short>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsInt32();
                 },
                 [](Local<Value> value) -> unsigned short {
                   return static_cast<unsigned short>(Nan::To<int32_t>(value).FromMaybe(0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<unsigned short>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorUInt16Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorUInt16Bit::CreateFromShapeArrayAndDataArray(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorUInt16Bit(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 CreateFromBuffer(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<__int64>^>(info[0]) || info[0]->IsArray())
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IBuffer^>(info[1]))
      {
        try
        {
          ::Platform::Array<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Storage::Streams::IBuffer^ arg1 = dynamic_cast<::Windows::Storage::Streams::IBuffer^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          ::Windows::AI::MachineLearning::TensorUInt16Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorUInt16Bit::CreateFromBuffer(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorUInt16Bit(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::AI::MachineLearning::TensorUInt16Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorUInt16Bit::Create();
          info.GetReturnValue().Set(WrapTensorUInt16Bit(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          ::Windows::AI::MachineLearning::TensorUInt16Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorUInt16Bit::Create(arg0);
          info.GetReturnValue().Set(WrapTensorUInt16Bit(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 CreateFromArray(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<unsigned short>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Platform::Array<unsigned short>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<unsigned short>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<unsigned short>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsInt32();
                 },
                 [](Local<Value> value) -> unsigned short {
                   return static_cast<unsigned short>(Nan::To<int32_t>(value).FromMaybe(0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<unsigned short>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorUInt16Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorUInt16Bit::CreateFromArray(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorUInt16Bit(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 CreateFromIterable(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<unsigned short>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Foundation::Collections::IIterable<unsigned short>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<unsigned short>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<unsigned short>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsInt32();
                 },
                 [](Local<Value> value) -> unsigned short {
                   return static_cast<unsigned short>(Nan::To<int32_t>(value).FromMaybe(0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<unsigned short>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorUInt16Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorUInt16Bit::CreateFromIterable(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorUInt16Bit(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 KindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorUInt16Bit^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorUInt16Bit^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<__int64>^ result = wrapper->_instance->Shape;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<__int64>::CreateVectorViewWrapper(result, 
            [](__int64 val) -> Local<Value> {
              return Nan::New<Number>(static_cast<double>(val));
            },
            [](Local<Value> value) -> bool {
              return value->IsNumber();
            },
            [](Local<Value> value) -> __int64 {
              return Nan::To<int64_t>(value).FromMaybe(0);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TensorKindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorUInt16Bit^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::AI::MachineLearning::TensorUInt16Bit^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapTensorUInt16Bit(::Windows::AI::MachineLearning::TensorUInt16Bit^ wintRtInstance);
      friend ::Windows::AI::MachineLearning::TensorUInt16Bit^ UnwrapTensorUInt16Bit(Local<Value> value);
  };

  Persistent<FunctionTemplate> TensorUInt16Bit::s_constructorTemplate;

  v8::Local<v8::Value> WrapTensorUInt16Bit(::Windows::AI::MachineLearning::TensorUInt16Bit^ 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>(TensorUInt16Bit::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::AI::MachineLearning::TensorUInt16Bit^ UnwrapTensorUInt16Bit(Local<Value> value) {
     return TensorUInt16Bit::Unwrap<TensorUInt16Bit>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitTensorUInt16Bit(Local<Object> exports) {
    TensorUInt16Bit::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getAsVectorView", GetAsVectorView);
            Nan::SetPrototypeMethod(localRef, "createReference", CreateReference);
            Nan::SetPrototypeMethod(localRef, "close", Close);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("shape").ToLocalChecked(), ShapeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("tensorKind").ToLocalChecked(), TensorKindGetter);

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

        Nan::SetMethod(constructor, "createFromShapeArrayAndDataArray", CreateFromShapeArrayAndDataArray);
        Nan::SetMethod(constructor, "createFromBuffer", CreateFromBuffer);
        Nan::SetMethod(constructor, "create", Create);
        Nan::SetMethod(constructor, "createFromArray", CreateFromArray);
        Nan::SetMethod(constructor, "createFromIterable", CreateFromIterable);


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

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

    private:

      TensorUInt32Bit(::Windows::AI::MachineLearning::TensorUInt32Bit^ 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::AI::MachineLearning::TensorUInt32Bit^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorUInt32Bit^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorUInt32Bit^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::IMemoryBufferReference^ result;
          result = wrapper->_instance->CreateReference();
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "IMemoryBufferReference", 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 Close(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorUInt32Bit^>(info.This())) {
        return;
      }

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

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

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<unsigned int>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Platform::Array<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Platform::Array<unsigned int>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<unsigned int>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<unsigned int>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsUint32();
                 },
                 [](Local<Value> value) -> unsigned int {
                   return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<unsigned int>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorUInt32Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorUInt32Bit::CreateFromShapeArrayAndDataArray(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorUInt32Bit(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 CreateFromBuffer(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<__int64>^>(info[0]) || info[0]->IsArray())
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IBuffer^>(info[1]))
      {
        try
        {
          ::Platform::Array<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Storage::Streams::IBuffer^ arg1 = dynamic_cast<::Windows::Storage::Streams::IBuffer^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          ::Windows::AI::MachineLearning::TensorUInt32Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorUInt32Bit::CreateFromBuffer(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorUInt32Bit(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::AI::MachineLearning::TensorUInt32Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorUInt32Bit::Create();
          info.GetReturnValue().Set(WrapTensorUInt32Bit(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          ::Windows::AI::MachineLearning::TensorUInt32Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorUInt32Bit::Create(arg0);
          info.GetReturnValue().Set(WrapTensorUInt32Bit(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 CreateFromArray(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<unsigned int>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Platform::Array<unsigned int>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<unsigned int>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<unsigned int>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsUint32();
                 },
                 [](Local<Value> value) -> unsigned int {
                   return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<unsigned int>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorUInt32Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorUInt32Bit::CreateFromArray(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorUInt32Bit(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 CreateFromIterable(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<unsigned int>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Foundation::Collections::IIterable<unsigned int>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<unsigned int>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<unsigned int>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsUint32();
                 },
                 [](Local<Value> value) -> unsigned int {
                   return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<unsigned int>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorUInt32Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorUInt32Bit::CreateFromIterable(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorUInt32Bit(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 KindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorUInt32Bit^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorUInt32Bit^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<__int64>^ result = wrapper->_instance->Shape;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<__int64>::CreateVectorViewWrapper(result, 
            [](__int64 val) -> Local<Value> {
              return Nan::New<Number>(static_cast<double>(val));
            },
            [](Local<Value> value) -> bool {
              return value->IsNumber();
            },
            [](Local<Value> value) -> __int64 {
              return Nan::To<int64_t>(value).FromMaybe(0);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TensorKindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorUInt32Bit^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::AI::MachineLearning::TensorUInt32Bit^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapTensorUInt32Bit(::Windows::AI::MachineLearning::TensorUInt32Bit^ wintRtInstance);
      friend ::Windows::AI::MachineLearning::TensorUInt32Bit^ UnwrapTensorUInt32Bit(Local<Value> value);
  };

  Persistent<FunctionTemplate> TensorUInt32Bit::s_constructorTemplate;

  v8::Local<v8::Value> WrapTensorUInt32Bit(::Windows::AI::MachineLearning::TensorUInt32Bit^ 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>(TensorUInt32Bit::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::AI::MachineLearning::TensorUInt32Bit^ UnwrapTensorUInt32Bit(Local<Value> value) {
     return TensorUInt32Bit::Unwrap<TensorUInt32Bit>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitTensorUInt32Bit(Local<Object> exports) {
    TensorUInt32Bit::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getAsVectorView", GetAsVectorView);
            Nan::SetPrototypeMethod(localRef, "createReference", CreateReference);
            Nan::SetPrototypeMethod(localRef, "close", Close);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("shape").ToLocalChecked(), ShapeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("tensorKind").ToLocalChecked(), TensorKindGetter);

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

        Nan::SetMethod(constructor, "createFromShapeArrayAndDataArray", CreateFromShapeArrayAndDataArray);
        Nan::SetMethod(constructor, "createFromBuffer", CreateFromBuffer);
        Nan::SetMethod(constructor, "create", Create);
        Nan::SetMethod(constructor, "createFromArray", CreateFromArray);
        Nan::SetMethod(constructor, "createFromIterable", CreateFromIterable);


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

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

    private:

      TensorUInt64Bit(::Windows::AI::MachineLearning::TensorUInt64Bit^ 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::AI::MachineLearning::TensorUInt64Bit^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorUInt64Bit^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<unsigned __int64>^ result;
          result = wrapper->_instance->GetAsVectorView();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned __int64>::CreateVectorViewWrapper(result, 
            [](unsigned __int64 val) -> Local<Value> {
              return Nan::New<Number>(static_cast<double>(val));
            },
            [](Local<Value> value) -> bool {
              return value->IsNumber();
            },
            [](Local<Value> value) -> unsigned __int64 {
              return static_cast<unsigned __int64>(Nan::To<int64_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 CreateReference(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorUInt64Bit^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::IMemoryBufferReference^ result;
          result = wrapper->_instance->CreateReference();
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "IMemoryBufferReference", 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 Close(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorUInt64Bit^>(info.This())) {
        return;
      }

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

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

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<unsigned __int64>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Platform::Array<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Platform::Array<unsigned __int64>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<unsigned __int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<unsigned __int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> unsigned __int64 {
                   return static_cast<unsigned __int64>(Nan::To<int64_t>(value).FromMaybe(0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<unsigned __int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorUInt64Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorUInt64Bit::CreateFromShapeArrayAndDataArray(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorUInt64Bit(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 CreateFromBuffer(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<__int64>^>(info[0]) || info[0]->IsArray())
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IBuffer^>(info[1]))
      {
        try
        {
          ::Platform::Array<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Storage::Streams::IBuffer^ arg1 = dynamic_cast<::Windows::Storage::Streams::IBuffer^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          ::Windows::AI::MachineLearning::TensorUInt64Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorUInt64Bit::CreateFromBuffer(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorUInt64Bit(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::AI::MachineLearning::TensorUInt64Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorUInt64Bit::Create();
          info.GetReturnValue().Set(WrapTensorUInt64Bit(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          ::Windows::AI::MachineLearning::TensorUInt64Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorUInt64Bit::Create(arg0);
          info.GetReturnValue().Set(WrapTensorUInt64Bit(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 CreateFromArray(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<unsigned __int64>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Platform::Array<unsigned __int64>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<unsigned __int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<unsigned __int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> unsigned __int64 {
                   return static_cast<unsigned __int64>(Nan::To<int64_t>(value).FromMaybe(0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<unsigned __int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorUInt64Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorUInt64Bit::CreateFromArray(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorUInt64Bit(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 CreateFromIterable(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<unsigned __int64>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Foundation::Collections::IIterable<unsigned __int64>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<unsigned __int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<unsigned __int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> unsigned __int64 {
                   return static_cast<unsigned __int64>(Nan::To<int64_t>(value).FromMaybe(0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<unsigned __int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorUInt64Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorUInt64Bit::CreateFromIterable(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorUInt64Bit(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 KindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorUInt64Bit^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorUInt64Bit^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<__int64>^ result = wrapper->_instance->Shape;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<__int64>::CreateVectorViewWrapper(result, 
            [](__int64 val) -> Local<Value> {
              return Nan::New<Number>(static_cast<double>(val));
            },
            [](Local<Value> value) -> bool {
              return value->IsNumber();
            },
            [](Local<Value> value) -> __int64 {
              return Nan::To<int64_t>(value).FromMaybe(0);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TensorKindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorUInt64Bit^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::AI::MachineLearning::TensorUInt64Bit^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapTensorUInt64Bit(::Windows::AI::MachineLearning::TensorUInt64Bit^ wintRtInstance);
      friend ::Windows::AI::MachineLearning::TensorUInt64Bit^ UnwrapTensorUInt64Bit(Local<Value> value);
  };

  Persistent<FunctionTemplate> TensorUInt64Bit::s_constructorTemplate;

  v8::Local<v8::Value> WrapTensorUInt64Bit(::Windows::AI::MachineLearning::TensorUInt64Bit^ 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>(TensorUInt64Bit::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::AI::MachineLearning::TensorUInt64Bit^ UnwrapTensorUInt64Bit(Local<Value> value) {
     return TensorUInt64Bit::Unwrap<TensorUInt64Bit>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitTensorUInt64Bit(Local<Object> exports) {
    TensorUInt64Bit::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getAsVectorView", GetAsVectorView);
            Nan::SetPrototypeMethod(localRef, "createReference", CreateReference);
            Nan::SetPrototypeMethod(localRef, "close", Close);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("shape").ToLocalChecked(), ShapeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("tensorKind").ToLocalChecked(), TensorKindGetter);

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

        Nan::SetMethod(constructor, "createFromShapeArrayAndDataArray", CreateFromShapeArrayAndDataArray);
        Nan::SetMethod(constructor, "createFromBuffer", CreateFromBuffer);
        Nan::SetMethod(constructor, "create", Create);
        Nan::SetMethod(constructor, "createFromArray", CreateFromArray);
        Nan::SetMethod(constructor, "createFromIterable", CreateFromIterable);


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

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

    private:

      TensorUInt8Bit(::Windows::AI::MachineLearning::TensorUInt8Bit^ 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::AI::MachineLearning::TensorUInt8Bit^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorUInt8Bit^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<unsigned char>^ result;
          result = wrapper->_instance->GetAsVectorView();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned char>::CreateVectorViewWrapper(result, 
            [](unsigned char val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsInt32();
            },
            [](Local<Value> value) -> unsigned char {
              return static_cast<unsigned char>(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 CreateReference(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorUInt8Bit^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::IMemoryBufferReference^ result;
          result = wrapper->_instance->CreateReference();
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "IMemoryBufferReference", 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 Close(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorUInt8Bit^>(info.This())) {
        return;
      }

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

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

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<unsigned char>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Platform::Array<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Platform::Array<unsigned char>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<unsigned char>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<unsigned char>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsInt32();
                 },
                 [](Local<Value> value) -> unsigned char {
                   return static_cast<unsigned char>(Nan::To<int32_t>(value).FromMaybe(0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<unsigned char>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorUInt8Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorUInt8Bit::CreateFromShapeArrayAndDataArray(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorUInt8Bit(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 CreateFromBuffer(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<__int64>^>(info[0]) || info[0]->IsArray())
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IBuffer^>(info[1]))
      {
        try
        {
          ::Platform::Array<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Storage::Streams::IBuffer^ arg1 = dynamic_cast<::Windows::Storage::Streams::IBuffer^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          ::Windows::AI::MachineLearning::TensorUInt8Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorUInt8Bit::CreateFromBuffer(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorUInt8Bit(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::AI::MachineLearning::TensorUInt8Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorUInt8Bit::Create();
          info.GetReturnValue().Set(WrapTensorUInt8Bit(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          ::Windows::AI::MachineLearning::TensorUInt8Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorUInt8Bit::Create(arg0);
          info.GetReturnValue().Set(WrapTensorUInt8Bit(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 CreateFromArray(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<unsigned char>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Platform::Array<unsigned char>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<unsigned char>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<unsigned char>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsInt32();
                 },
                 [](Local<Value> value) -> unsigned char {
                   return static_cast<unsigned char>(Nan::To<int32_t>(value).FromMaybe(0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<unsigned char>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorUInt8Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorUInt8Bit::CreateFromArray(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorUInt8Bit(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 CreateFromIterable(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<__int64>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<unsigned char>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<__int64>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<__int64>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<__int64>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsNumber();
                 },
                 [](Local<Value> value) -> __int64 {
                   return Nan::To<int64_t>(value).FromMaybe(0);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<__int64>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Foundation::Collections::IIterable<unsigned char>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<unsigned char>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<unsigned char>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsInt32();
                 },
                 [](Local<Value> value) -> unsigned char {
                   return static_cast<unsigned char>(Nan::To<int32_t>(value).FromMaybe(0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<unsigned char>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          ::Windows::AI::MachineLearning::TensorUInt8Bit^ result;
          result = ::Windows::AI::MachineLearning::TensorUInt8Bit::CreateFromIterable(arg0, arg1);
          info.GetReturnValue().Set(WrapTensorUInt8Bit(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 KindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorUInt8Bit^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorUInt8Bit^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<__int64>^ result = wrapper->_instance->Shape;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<__int64>::CreateVectorViewWrapper(result, 
            [](__int64 val) -> Local<Value> {
              return Nan::New<Number>(static_cast<double>(val));
            },
            [](Local<Value> value) -> bool {
              return value->IsNumber();
            },
            [](Local<Value> value) -> __int64 {
              return Nan::To<int64_t>(value).FromMaybe(0);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TensorKindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::AI::MachineLearning::TensorUInt8Bit^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::AI::MachineLearning::TensorUInt8Bit^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapTensorUInt8Bit(::Windows::AI::MachineLearning::TensorUInt8Bit^ wintRtInstance);
      friend ::Windows::AI::MachineLearning::TensorUInt8Bit^ UnwrapTensorUInt8Bit(Local<Value> value);
  };

  Persistent<FunctionTemplate> TensorUInt8Bit::s_constructorTemplate;

  v8::Local<v8::Value> WrapTensorUInt8Bit(::Windows::AI::MachineLearning::TensorUInt8Bit^ 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>(TensorUInt8Bit::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::AI::MachineLearning::TensorUInt8Bit^ UnwrapTensorUInt8Bit(Local<Value> value) {
     return TensorUInt8Bit::Unwrap<TensorUInt8Bit>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitTensorUInt8Bit(Local<Object> exports) {
    TensorUInt8Bit::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::AI::MachineLearning::InitLearningModelDeviceKindEnum(target);
      NodeRT::Windows::AI::MachineLearning::InitLearningModelFeatureKindEnum(target);
      NodeRT::Windows::AI::MachineLearning::InitLearningModelPixelRangeEnum(target);
      NodeRT::Windows::AI::MachineLearning::InitTensorKindEnum(target);
      NodeRT::Windows::AI::MachineLearning::InitILearningModelFeatureDescriptor(target);
      NodeRT::Windows::AI::MachineLearning::InitILearningModelFeatureValue(target);
      NodeRT::Windows::AI::MachineLearning::InitILearningModelOperatorProvider(target);
      NodeRT::Windows::AI::MachineLearning::InitITensor(target);
      NodeRT::Windows::AI::MachineLearning::InitImageFeatureDescriptor(target);
      NodeRT::Windows::AI::MachineLearning::InitImageFeatureValue(target);
      NodeRT::Windows::AI::MachineLearning::InitLearningModel(target);
      NodeRT::Windows::AI::MachineLearning::InitLearningModelBinding(target);
      NodeRT::Windows::AI::MachineLearning::InitLearningModelDevice(target);
      NodeRT::Windows::AI::MachineLearning::InitLearningModelEvaluationResult(target);
      NodeRT::Windows::AI::MachineLearning::InitLearningModelSession(target);
      NodeRT::Windows::AI::MachineLearning::InitLearningModelSessionOptions(target);
      NodeRT::Windows::AI::MachineLearning::InitMapFeatureDescriptor(target);
      NodeRT::Windows::AI::MachineLearning::InitSequenceFeatureDescriptor(target);
      NodeRT::Windows::AI::MachineLearning::InitTensorBoolean(target);
      NodeRT::Windows::AI::MachineLearning::InitTensorDouble(target);
      NodeRT::Windows::AI::MachineLearning::InitTensorFeatureDescriptor(target);
      NodeRT::Windows::AI::MachineLearning::InitTensorFloat(target);
      NodeRT::Windows::AI::MachineLearning::InitTensorFloat16Bit(target);
      NodeRT::Windows::AI::MachineLearning::InitTensorInt16Bit(target);
      NodeRT::Windows::AI::MachineLearning::InitTensorInt32Bit(target);
      NodeRT::Windows::AI::MachineLearning::InitTensorInt64Bit(target);
      NodeRT::Windows::AI::MachineLearning::InitTensorInt8Bit(target);
      NodeRT::Windows::AI::MachineLearning::InitTensorString(target);
      NodeRT::Windows::AI::MachineLearning::InitTensorUInt16Bit(target);
      NodeRT::Windows::AI::MachineLearning::InitTensorUInt32Bit(target);
      NodeRT::Windows::AI::MachineLearning::InitTensorUInt64Bit(target);
      NodeRT::Windows::AI::MachineLearning::InitTensorUInt8Bit(target);


  NodeRT::Utils::RegisterNameSpace("Windows.AI.MachineLearning", target);
}



NODE_MODULE(binding, init)