// 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 Devices { namespace Perception { 
  v8::Local<v8::Value> WrapPerceptionColorFrameSourceWatcher(::Windows::Devices::Perception::PerceptionColorFrameSourceWatcher^ wintRtInstance);
  ::Windows::Devices::Perception::PerceptionColorFrameSourceWatcher^ UnwrapPerceptionColorFrameSourceWatcher(Local<Value> value);
  
  v8::Local<v8::Value> WrapPerceptionColorFrameSourceAddedEventArgs(::Windows::Devices::Perception::PerceptionColorFrameSourceAddedEventArgs^ wintRtInstance);
  ::Windows::Devices::Perception::PerceptionColorFrameSourceAddedEventArgs^ UnwrapPerceptionColorFrameSourceAddedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapPerceptionColorFrameSourceRemovedEventArgs(::Windows::Devices::Perception::PerceptionColorFrameSourceRemovedEventArgs^ wintRtInstance);
  ::Windows::Devices::Perception::PerceptionColorFrameSourceRemovedEventArgs^ UnwrapPerceptionColorFrameSourceRemovedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapPerceptionDepthFrameSourceWatcher(::Windows::Devices::Perception::PerceptionDepthFrameSourceWatcher^ wintRtInstance);
  ::Windows::Devices::Perception::PerceptionDepthFrameSourceWatcher^ UnwrapPerceptionDepthFrameSourceWatcher(Local<Value> value);
  
  v8::Local<v8::Value> WrapPerceptionDepthFrameSourceAddedEventArgs(::Windows::Devices::Perception::PerceptionDepthFrameSourceAddedEventArgs^ wintRtInstance);
  ::Windows::Devices::Perception::PerceptionDepthFrameSourceAddedEventArgs^ UnwrapPerceptionDepthFrameSourceAddedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapPerceptionDepthFrameSourceRemovedEventArgs(::Windows::Devices::Perception::PerceptionDepthFrameSourceRemovedEventArgs^ wintRtInstance);
  ::Windows::Devices::Perception::PerceptionDepthFrameSourceRemovedEventArgs^ UnwrapPerceptionDepthFrameSourceRemovedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapPerceptionInfraredFrameSourceWatcher(::Windows::Devices::Perception::PerceptionInfraredFrameSourceWatcher^ wintRtInstance);
  ::Windows::Devices::Perception::PerceptionInfraredFrameSourceWatcher^ UnwrapPerceptionInfraredFrameSourceWatcher(Local<Value> value);
  
  v8::Local<v8::Value> WrapPerceptionInfraredFrameSourceAddedEventArgs(::Windows::Devices::Perception::PerceptionInfraredFrameSourceAddedEventArgs^ wintRtInstance);
  ::Windows::Devices::Perception::PerceptionInfraredFrameSourceAddedEventArgs^ UnwrapPerceptionInfraredFrameSourceAddedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapPerceptionInfraredFrameSourceRemovedEventArgs(::Windows::Devices::Perception::PerceptionInfraredFrameSourceRemovedEventArgs^ wintRtInstance);
  ::Windows::Devices::Perception::PerceptionInfraredFrameSourceRemovedEventArgs^ UnwrapPerceptionInfraredFrameSourceRemovedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapPerceptionColorFrameSource(::Windows::Devices::Perception::PerceptionColorFrameSource^ wintRtInstance);
  ::Windows::Devices::Perception::PerceptionColorFrameSource^ UnwrapPerceptionColorFrameSource(Local<Value> value);
  
  v8::Local<v8::Value> WrapPerceptionDepthFrameSource(::Windows::Devices::Perception::PerceptionDepthFrameSource^ wintRtInstance);
  ::Windows::Devices::Perception::PerceptionDepthFrameSource^ UnwrapPerceptionDepthFrameSource(Local<Value> value);
  
  v8::Local<v8::Value> WrapPerceptionInfraredFrameSource(::Windows::Devices::Perception::PerceptionInfraredFrameSource^ wintRtInstance);
  ::Windows::Devices::Perception::PerceptionInfraredFrameSource^ UnwrapPerceptionInfraredFrameSource(Local<Value> value);
  
  v8::Local<v8::Value> WrapPerceptionControlSession(::Windows::Devices::Perception::PerceptionControlSession^ wintRtInstance);
  ::Windows::Devices::Perception::PerceptionControlSession^ UnwrapPerceptionControlSession(Local<Value> value);
  
  v8::Local<v8::Value> WrapPerceptionFrameSourcePropertyChangeResult(::Windows::Devices::Perception::PerceptionFrameSourcePropertyChangeResult^ wintRtInstance);
  ::Windows::Devices::Perception::PerceptionFrameSourcePropertyChangeResult^ UnwrapPerceptionFrameSourcePropertyChangeResult(Local<Value> value);
  
  v8::Local<v8::Value> WrapPerceptionFrameSourcePropertiesChangedEventArgs(::Windows::Devices::Perception::PerceptionFrameSourcePropertiesChangedEventArgs^ wintRtInstance);
  ::Windows::Devices::Perception::PerceptionFrameSourcePropertiesChangedEventArgs^ UnwrapPerceptionFrameSourcePropertiesChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapPerceptionVideoProfile(::Windows::Devices::Perception::PerceptionVideoProfile^ wintRtInstance);
  ::Windows::Devices::Perception::PerceptionVideoProfile^ UnwrapPerceptionVideoProfile(Local<Value> value);
  
  v8::Local<v8::Value> WrapPerceptionDepthCorrelatedCameraIntrinsics(::Windows::Devices::Perception::PerceptionDepthCorrelatedCameraIntrinsics^ wintRtInstance);
  ::Windows::Devices::Perception::PerceptionDepthCorrelatedCameraIntrinsics^ UnwrapPerceptionDepthCorrelatedCameraIntrinsics(Local<Value> value);
  
  v8::Local<v8::Value> WrapPerceptionDepthCorrelatedCoordinateMapper(::Windows::Devices::Perception::PerceptionDepthCorrelatedCoordinateMapper^ wintRtInstance);
  ::Windows::Devices::Perception::PerceptionDepthCorrelatedCoordinateMapper^ UnwrapPerceptionDepthCorrelatedCoordinateMapper(Local<Value> value);
  
  v8::Local<v8::Value> WrapPerceptionColorFrameReader(::Windows::Devices::Perception::PerceptionColorFrameReader^ wintRtInstance);
  ::Windows::Devices::Perception::PerceptionColorFrameReader^ UnwrapPerceptionColorFrameReader(Local<Value> value);
  
  v8::Local<v8::Value> WrapPerceptionDepthFrameReader(::Windows::Devices::Perception::PerceptionDepthFrameReader^ wintRtInstance);
  ::Windows::Devices::Perception::PerceptionDepthFrameReader^ UnwrapPerceptionDepthFrameReader(Local<Value> value);
  
  v8::Local<v8::Value> WrapPerceptionInfraredFrameReader(::Windows::Devices::Perception::PerceptionInfraredFrameReader^ wintRtInstance);
  ::Windows::Devices::Perception::PerceptionInfraredFrameReader^ UnwrapPerceptionInfraredFrameReader(Local<Value> value);
  
  v8::Local<v8::Value> WrapPerceptionColorFrameArrivedEventArgs(::Windows::Devices::Perception::PerceptionColorFrameArrivedEventArgs^ wintRtInstance);
  ::Windows::Devices::Perception::PerceptionColorFrameArrivedEventArgs^ UnwrapPerceptionColorFrameArrivedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapPerceptionColorFrame(::Windows::Devices::Perception::PerceptionColorFrame^ wintRtInstance);
  ::Windows::Devices::Perception::PerceptionColorFrame^ UnwrapPerceptionColorFrame(Local<Value> value);
  
  v8::Local<v8::Value> WrapPerceptionDepthFrameArrivedEventArgs(::Windows::Devices::Perception::PerceptionDepthFrameArrivedEventArgs^ wintRtInstance);
  ::Windows::Devices::Perception::PerceptionDepthFrameArrivedEventArgs^ UnwrapPerceptionDepthFrameArrivedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapPerceptionDepthFrame(::Windows::Devices::Perception::PerceptionDepthFrame^ wintRtInstance);
  ::Windows::Devices::Perception::PerceptionDepthFrame^ UnwrapPerceptionDepthFrame(Local<Value> value);
  
  v8::Local<v8::Value> WrapPerceptionInfraredFrameArrivedEventArgs(::Windows::Devices::Perception::PerceptionInfraredFrameArrivedEventArgs^ wintRtInstance);
  ::Windows::Devices::Perception::PerceptionInfraredFrameArrivedEventArgs^ UnwrapPerceptionInfraredFrameArrivedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapPerceptionInfraredFrame(::Windows::Devices::Perception::PerceptionInfraredFrame^ wintRtInstance);
  ::Windows::Devices::Perception::PerceptionInfraredFrame^ UnwrapPerceptionInfraredFrame(Local<Value> value);
  
  v8::Local<v8::Value> WrapKnownPerceptionFrameSourceProperties(::Windows::Devices::Perception::KnownPerceptionFrameSourceProperties^ wintRtInstance);
  ::Windows::Devices::Perception::KnownPerceptionFrameSourceProperties^ UnwrapKnownPerceptionFrameSourceProperties(Local<Value> value);
  
  v8::Local<v8::Value> WrapKnownPerceptionVideoFrameSourceProperties(::Windows::Devices::Perception::KnownPerceptionVideoFrameSourceProperties^ wintRtInstance);
  ::Windows::Devices::Perception::KnownPerceptionVideoFrameSourceProperties^ UnwrapKnownPerceptionVideoFrameSourceProperties(Local<Value> value);
  
  v8::Local<v8::Value> WrapKnownPerceptionInfraredFrameSourceProperties(::Windows::Devices::Perception::KnownPerceptionInfraredFrameSourceProperties^ wintRtInstance);
  ::Windows::Devices::Perception::KnownPerceptionInfraredFrameSourceProperties^ UnwrapKnownPerceptionInfraredFrameSourceProperties(Local<Value> value);
  
  v8::Local<v8::Value> WrapKnownPerceptionDepthFrameSourceProperties(::Windows::Devices::Perception::KnownPerceptionDepthFrameSourceProperties^ wintRtInstance);
  ::Windows::Devices::Perception::KnownPerceptionDepthFrameSourceProperties^ UnwrapKnownPerceptionDepthFrameSourceProperties(Local<Value> value);
  
  v8::Local<v8::Value> WrapKnownPerceptionColorFrameSourceProperties(::Windows::Devices::Perception::KnownPerceptionColorFrameSourceProperties^ wintRtInstance);
  ::Windows::Devices::Perception::KnownPerceptionColorFrameSourceProperties^ UnwrapKnownPerceptionColorFrameSourceProperties(Local<Value> value);
  
  v8::Local<v8::Value> WrapKnownPerceptionVideoProfileProperties(::Windows::Devices::Perception::KnownPerceptionVideoProfileProperties^ wintRtInstance);
  ::Windows::Devices::Perception::KnownPerceptionVideoProfileProperties^ UnwrapKnownPerceptionVideoProfileProperties(Local<Value> value);
  
  v8::Local<v8::Value> WrapKnownCameraIntrinsicsProperties(::Windows::Devices::Perception::KnownCameraIntrinsicsProperties^ wintRtInstance);
  ::Windows::Devices::Perception::KnownCameraIntrinsicsProperties^ UnwrapKnownCameraIntrinsicsProperties(Local<Value> value);
  



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

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

    Nan::Set(exports, Nan::New<String>("PerceptionFrameSourceAccessStatus").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("unspecified").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::Perception::PerceptionFrameSourceAccessStatus::Unspecified)));
    Nan::Set(enumObject, Nan::New<String>("allowed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::Perception::PerceptionFrameSourceAccessStatus::Allowed)));
    Nan::Set(enumObject, Nan::New<String>("deniedByUser").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::Perception::PerceptionFrameSourceAccessStatus::DeniedByUser)));
    Nan::Set(enumObject, Nan::New<String>("deniedBySystem").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::Perception::PerceptionFrameSourceAccessStatus::DeniedBySystem)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("PerceptionFrameSourcePropertyChangeStatus").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("unknown").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::Perception::PerceptionFrameSourcePropertyChangeStatus::Unknown)));
    Nan::Set(enumObject, Nan::New<String>("accepted").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::Perception::PerceptionFrameSourcePropertyChangeStatus::Accepted)));
    Nan::Set(enumObject, Nan::New<String>("lostControl").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::Perception::PerceptionFrameSourcePropertyChangeStatus::LostControl)));
    Nan::Set(enumObject, Nan::New<String>("propertyNotSupported").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::Perception::PerceptionFrameSourcePropertyChangeStatus::PropertyNotSupported)));
    Nan::Set(enumObject, Nan::New<String>("propertyReadOnly").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::Perception::PerceptionFrameSourcePropertyChangeStatus::PropertyReadOnly)));
    Nan::Set(enumObject, Nan::New<String>("valueOutOfRange").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::Perception::PerceptionFrameSourcePropertyChangeStatus::ValueOutOfRange)));
  }


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

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

    return true;
  }

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

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

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

    return returnValue;
  }

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

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


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

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

    symbol = Nan::New<String>("x").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("y").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("z").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    return true;
  }

  ::Platform::Numerics::Vector3 Vector3FromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Platform::Numerics::Vector3 returnValue;

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

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

    symbol = Nan::New<String>("x").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.X = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("y").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.Y = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    symbol = Nan::New<String>("z").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.Z = static_cast<float>(Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0));
    }
    
    return returnValue;
  }

  Local<Value> Vector3ToJsObject(::Platform::Numerics::Vector3 value) {
    EscapableHandleScope scope;

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

    Nan::Set(obj, Nan::New<String>("x").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.X)));
    Nan::Set(obj, Nan::New<String>("y").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.Y)));
    Nan::Set(obj, Nan::New<String>("z").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.Z)));

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

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

    return true;
  }

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

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

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

    return returnValue;
  }

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

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


    return scope.Escape(obj);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "start", Start);
            Nan::SetPrototypeMethod(localRef, "stop", Stop);
          


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

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

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



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

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

    private:

      PerceptionColorFrameSourceWatcher(::Windows::Devices::Perception::PerceptionColorFrameSourceWatcher^ 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::Devices::Perception::PerceptionColorFrameSourceWatcher^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSourceWatcher^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSourceWatcher^>(info.This())) {
        return;
      }

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

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



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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSourceWatcher^>(info.This())) {
        return;
      }

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

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


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

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"enumerationCompleted", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSourceWatcher^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionColorFrameSourceWatcher *wrapper = PerceptionColorFrameSourceWatcher::Unwrap<PerceptionColorFrameSourceWatcher>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->EnumerationCompleted::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionColorFrameSourceWatcher^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionColorFrameSourceWatcher^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionColorFrameSourceWatcher(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"sourceAdded", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSourceWatcher^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionColorFrameSourceWatcher *wrapper = PerceptionColorFrameSourceWatcher::Unwrap<PerceptionColorFrameSourceWatcher>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->SourceAdded::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionColorFrameSourceWatcher^, ::Windows::Devices::Perception::PerceptionColorFrameSourceAddedEventArgs^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionColorFrameSourceWatcher^ arg0, ::Windows::Devices::Perception::PerceptionColorFrameSourceAddedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionColorFrameSourceWatcher(arg0);
                  wrappedArg1 = WrapPerceptionColorFrameSourceAddedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"sourceRemoved", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSourceWatcher^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionColorFrameSourceWatcher *wrapper = PerceptionColorFrameSourceWatcher::Unwrap<PerceptionColorFrameSourceWatcher>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->SourceRemoved::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionColorFrameSourceWatcher^, ::Windows::Devices::Perception::PerceptionColorFrameSourceRemovedEventArgs^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionColorFrameSourceWatcher^ arg0, ::Windows::Devices::Perception::PerceptionColorFrameSourceRemovedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionColorFrameSourceWatcher(arg0);
                  wrappedArg1 = WrapPerceptionColorFrameSourceRemovedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"stopped", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSourceWatcher^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionColorFrameSourceWatcher *wrapper = PerceptionColorFrameSourceWatcher::Unwrap<PerceptionColorFrameSourceWatcher>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->Stopped::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionColorFrameSourceWatcher^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionColorFrameSourceWatcher^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionColorFrameSourceWatcher(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
 else  {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Value> tokenMapVal = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());
      Local<Object> tokenMap;

      if (tokenMapVal.IsEmpty() || Nan::Equals(tokenMapVal, Undefined()).FromMaybe(false)) {
        tokenMap = Nan::New<Object>();
        NodeRT::Utils::SetHiddenValueWithObject(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked(), tokenMap);
      } else {
        tokenMap = Nan::To<Object>(tokenMapVal).ToLocalChecked();
      }

      Nan::Set(tokenMap, info[0], CreateOpaqueWrapper(::Windows::Foundation::PropertyValue::CreateInt64(registrationToken.Value)));
    }

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

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected a string and a callback")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      if ((!NodeRT::Utils::CaseInsenstiveEquals(L"enumerationCompleted", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"sourceAdded", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"sourceRemoved", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"stopped", str))) {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Function> callback = info[1].As<Function>();
      Local<Value> tokenMap = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());

      if (tokenMap.IsEmpty() || Nan::Equals(tokenMap, Undefined()).FromMaybe(false)) {
        return;
      }

      Local<Value> opaqueWrapperObj =  Nan::Get(Nan::To<Object>(tokenMap).ToLocalChecked(), info[0]).ToLocalChecked();

      if (opaqueWrapperObj.IsEmpty() || Nan::Equals(opaqueWrapperObj,Undefined()).FromMaybe(false)) {
        return;
      }

      OpaqueWrapper *opaqueWrapper = OpaqueWrapper::Unwrap<OpaqueWrapper>(opaqueWrapperObj.As<Object>());

      long long tokenValue = (long long) opaqueWrapper->GetObjectInstance();
      ::Windows::Foundation::EventRegistrationToken registrationToken;
      registrationToken.Value = tokenValue;

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"enumerationCompleted", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSourceWatcher^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionColorFrameSourceWatcher *wrapper = PerceptionColorFrameSourceWatcher::Unwrap<PerceptionColorFrameSourceWatcher>(info.This());
          wrapper->_instance->EnumerationCompleted::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"sourceAdded", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSourceWatcher^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionColorFrameSourceWatcher *wrapper = PerceptionColorFrameSourceWatcher::Unwrap<PerceptionColorFrameSourceWatcher>(info.This());
          wrapper->_instance->SourceAdded::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"sourceRemoved", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSourceWatcher^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionColorFrameSourceWatcher *wrapper = PerceptionColorFrameSourceWatcher::Unwrap<PerceptionColorFrameSourceWatcher>(info.This());
          wrapper->_instance->SourceRemoved::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"stopped", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSourceWatcher^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionColorFrameSourceWatcher *wrapper = PerceptionColorFrameSourceWatcher::Unwrap<PerceptionColorFrameSourceWatcher>(info.This());
          wrapper->_instance->Stopped::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

      Nan::Delete(Nan::To<Object>(tokenMap).ToLocalChecked(), Nan::To<String>(info[0]).ToLocalChecked());
    }
    private:
      ::Windows::Devices::Perception::PerceptionColorFrameSourceWatcher^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPerceptionColorFrameSourceWatcher(::Windows::Devices::Perception::PerceptionColorFrameSourceWatcher^ wintRtInstance);
      friend ::Windows::Devices::Perception::PerceptionColorFrameSourceWatcher^ UnwrapPerceptionColorFrameSourceWatcher(Local<Value> value);
  };

  Persistent<FunctionTemplate> PerceptionColorFrameSourceWatcher::s_constructorTemplate;

  v8::Local<v8::Value> WrapPerceptionColorFrameSourceWatcher(::Windows::Devices::Perception::PerceptionColorFrameSourceWatcher^ 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>(PerceptionColorFrameSourceWatcher::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::PerceptionColorFrameSourceWatcher^ UnwrapPerceptionColorFrameSourceWatcher(Local<Value> value) {
     return PerceptionColorFrameSourceWatcher::Unwrap<PerceptionColorFrameSourceWatcher>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPerceptionColorFrameSourceWatcher(Local<Object> exports) {
    PerceptionColorFrameSourceWatcher::Init(exports);
  }

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





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

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



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

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

    private:

      PerceptionColorFrameSourceAddedEventArgs(::Windows::Devices::Perception::PerceptionColorFrameSourceAddedEventArgs^ 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::Devices::Perception::PerceptionColorFrameSourceAddedEventArgs^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSourceAddedEventArgs^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Devices::Perception::PerceptionColorFrameSource^ result = wrapper->_instance->FrameSource;
        info.GetReturnValue().Set(WrapPerceptionColorFrameSource(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Devices::Perception::PerceptionColorFrameSourceAddedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPerceptionColorFrameSourceAddedEventArgs(::Windows::Devices::Perception::PerceptionColorFrameSourceAddedEventArgs^ wintRtInstance);
      friend ::Windows::Devices::Perception::PerceptionColorFrameSourceAddedEventArgs^ UnwrapPerceptionColorFrameSourceAddedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> PerceptionColorFrameSourceAddedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapPerceptionColorFrameSourceAddedEventArgs(::Windows::Devices::Perception::PerceptionColorFrameSourceAddedEventArgs^ 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>(PerceptionColorFrameSourceAddedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::PerceptionColorFrameSourceAddedEventArgs^ UnwrapPerceptionColorFrameSourceAddedEventArgs(Local<Value> value) {
     return PerceptionColorFrameSourceAddedEventArgs::Unwrap<PerceptionColorFrameSourceAddedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPerceptionColorFrameSourceAddedEventArgs(Local<Object> exports) {
    PerceptionColorFrameSourceAddedEventArgs::Init(exports);
  }

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





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

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



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

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

    private:

      PerceptionColorFrameSourceRemovedEventArgs(::Windows::Devices::Perception::PerceptionColorFrameSourceRemovedEventArgs^ 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::Devices::Perception::PerceptionColorFrameSourceRemovedEventArgs^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSourceRemovedEventArgs^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Devices::Perception::PerceptionColorFrameSource^ result = wrapper->_instance->FrameSource;
        info.GetReturnValue().Set(WrapPerceptionColorFrameSource(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Devices::Perception::PerceptionColorFrameSourceRemovedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPerceptionColorFrameSourceRemovedEventArgs(::Windows::Devices::Perception::PerceptionColorFrameSourceRemovedEventArgs^ wintRtInstance);
      friend ::Windows::Devices::Perception::PerceptionColorFrameSourceRemovedEventArgs^ UnwrapPerceptionColorFrameSourceRemovedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> PerceptionColorFrameSourceRemovedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapPerceptionColorFrameSourceRemovedEventArgs(::Windows::Devices::Perception::PerceptionColorFrameSourceRemovedEventArgs^ 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>(PerceptionColorFrameSourceRemovedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::PerceptionColorFrameSourceRemovedEventArgs^ UnwrapPerceptionColorFrameSourceRemovedEventArgs(Local<Value> value) {
     return PerceptionColorFrameSourceRemovedEventArgs::Unwrap<PerceptionColorFrameSourceRemovedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPerceptionColorFrameSourceRemovedEventArgs(Local<Object> exports) {
    PerceptionColorFrameSourceRemovedEventArgs::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "start", Start);
            Nan::SetPrototypeMethod(localRef, "stop", Stop);
          


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

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

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



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

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

    private:

      PerceptionDepthFrameSourceWatcher(::Windows::Devices::Perception::PerceptionDepthFrameSourceWatcher^ 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::Devices::Perception::PerceptionDepthFrameSourceWatcher^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSourceWatcher^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSourceWatcher^>(info.This())) {
        return;
      }

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

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



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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSourceWatcher^>(info.This())) {
        return;
      }

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

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


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

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"enumerationCompleted", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSourceWatcher^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionDepthFrameSourceWatcher *wrapper = PerceptionDepthFrameSourceWatcher::Unwrap<PerceptionDepthFrameSourceWatcher>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->EnumerationCompleted::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionDepthFrameSourceWatcher^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionDepthFrameSourceWatcher^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionDepthFrameSourceWatcher(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"sourceAdded", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSourceWatcher^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionDepthFrameSourceWatcher *wrapper = PerceptionDepthFrameSourceWatcher::Unwrap<PerceptionDepthFrameSourceWatcher>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->SourceAdded::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionDepthFrameSourceWatcher^, ::Windows::Devices::Perception::PerceptionDepthFrameSourceAddedEventArgs^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionDepthFrameSourceWatcher^ arg0, ::Windows::Devices::Perception::PerceptionDepthFrameSourceAddedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionDepthFrameSourceWatcher(arg0);
                  wrappedArg1 = WrapPerceptionDepthFrameSourceAddedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"sourceRemoved", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSourceWatcher^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionDepthFrameSourceWatcher *wrapper = PerceptionDepthFrameSourceWatcher::Unwrap<PerceptionDepthFrameSourceWatcher>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->SourceRemoved::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionDepthFrameSourceWatcher^, ::Windows::Devices::Perception::PerceptionDepthFrameSourceRemovedEventArgs^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionDepthFrameSourceWatcher^ arg0, ::Windows::Devices::Perception::PerceptionDepthFrameSourceRemovedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionDepthFrameSourceWatcher(arg0);
                  wrappedArg1 = WrapPerceptionDepthFrameSourceRemovedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"stopped", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSourceWatcher^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionDepthFrameSourceWatcher *wrapper = PerceptionDepthFrameSourceWatcher::Unwrap<PerceptionDepthFrameSourceWatcher>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->Stopped::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionDepthFrameSourceWatcher^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionDepthFrameSourceWatcher^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionDepthFrameSourceWatcher(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
 else  {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Value> tokenMapVal = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());
      Local<Object> tokenMap;

      if (tokenMapVal.IsEmpty() || Nan::Equals(tokenMapVal, Undefined()).FromMaybe(false)) {
        tokenMap = Nan::New<Object>();
        NodeRT::Utils::SetHiddenValueWithObject(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked(), tokenMap);
      } else {
        tokenMap = Nan::To<Object>(tokenMapVal).ToLocalChecked();
      }

      Nan::Set(tokenMap, info[0], CreateOpaqueWrapper(::Windows::Foundation::PropertyValue::CreateInt64(registrationToken.Value)));
    }

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

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected a string and a callback")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      if ((!NodeRT::Utils::CaseInsenstiveEquals(L"enumerationCompleted", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"sourceAdded", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"sourceRemoved", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"stopped", str))) {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Function> callback = info[1].As<Function>();
      Local<Value> tokenMap = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());

      if (tokenMap.IsEmpty() || Nan::Equals(tokenMap, Undefined()).FromMaybe(false)) {
        return;
      }

      Local<Value> opaqueWrapperObj =  Nan::Get(Nan::To<Object>(tokenMap).ToLocalChecked(), info[0]).ToLocalChecked();

      if (opaqueWrapperObj.IsEmpty() || Nan::Equals(opaqueWrapperObj,Undefined()).FromMaybe(false)) {
        return;
      }

      OpaqueWrapper *opaqueWrapper = OpaqueWrapper::Unwrap<OpaqueWrapper>(opaqueWrapperObj.As<Object>());

      long long tokenValue = (long long) opaqueWrapper->GetObjectInstance();
      ::Windows::Foundation::EventRegistrationToken registrationToken;
      registrationToken.Value = tokenValue;

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"enumerationCompleted", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSourceWatcher^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionDepthFrameSourceWatcher *wrapper = PerceptionDepthFrameSourceWatcher::Unwrap<PerceptionDepthFrameSourceWatcher>(info.This());
          wrapper->_instance->EnumerationCompleted::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"sourceAdded", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSourceWatcher^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionDepthFrameSourceWatcher *wrapper = PerceptionDepthFrameSourceWatcher::Unwrap<PerceptionDepthFrameSourceWatcher>(info.This());
          wrapper->_instance->SourceAdded::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"sourceRemoved", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSourceWatcher^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionDepthFrameSourceWatcher *wrapper = PerceptionDepthFrameSourceWatcher::Unwrap<PerceptionDepthFrameSourceWatcher>(info.This());
          wrapper->_instance->SourceRemoved::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"stopped", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSourceWatcher^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionDepthFrameSourceWatcher *wrapper = PerceptionDepthFrameSourceWatcher::Unwrap<PerceptionDepthFrameSourceWatcher>(info.This());
          wrapper->_instance->Stopped::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

      Nan::Delete(Nan::To<Object>(tokenMap).ToLocalChecked(), Nan::To<String>(info[0]).ToLocalChecked());
    }
    private:
      ::Windows::Devices::Perception::PerceptionDepthFrameSourceWatcher^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPerceptionDepthFrameSourceWatcher(::Windows::Devices::Perception::PerceptionDepthFrameSourceWatcher^ wintRtInstance);
      friend ::Windows::Devices::Perception::PerceptionDepthFrameSourceWatcher^ UnwrapPerceptionDepthFrameSourceWatcher(Local<Value> value);
  };

  Persistent<FunctionTemplate> PerceptionDepthFrameSourceWatcher::s_constructorTemplate;

  v8::Local<v8::Value> WrapPerceptionDepthFrameSourceWatcher(::Windows::Devices::Perception::PerceptionDepthFrameSourceWatcher^ 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>(PerceptionDepthFrameSourceWatcher::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::PerceptionDepthFrameSourceWatcher^ UnwrapPerceptionDepthFrameSourceWatcher(Local<Value> value) {
     return PerceptionDepthFrameSourceWatcher::Unwrap<PerceptionDepthFrameSourceWatcher>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPerceptionDepthFrameSourceWatcher(Local<Object> exports) {
    PerceptionDepthFrameSourceWatcher::Init(exports);
  }

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





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

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



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

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

    private:

      PerceptionDepthFrameSourceAddedEventArgs(::Windows::Devices::Perception::PerceptionDepthFrameSourceAddedEventArgs^ 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::Devices::Perception::PerceptionDepthFrameSourceAddedEventArgs^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSourceAddedEventArgs^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Devices::Perception::PerceptionDepthFrameSource^ result = wrapper->_instance->FrameSource;
        info.GetReturnValue().Set(WrapPerceptionDepthFrameSource(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Devices::Perception::PerceptionDepthFrameSourceAddedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPerceptionDepthFrameSourceAddedEventArgs(::Windows::Devices::Perception::PerceptionDepthFrameSourceAddedEventArgs^ wintRtInstance);
      friend ::Windows::Devices::Perception::PerceptionDepthFrameSourceAddedEventArgs^ UnwrapPerceptionDepthFrameSourceAddedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> PerceptionDepthFrameSourceAddedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapPerceptionDepthFrameSourceAddedEventArgs(::Windows::Devices::Perception::PerceptionDepthFrameSourceAddedEventArgs^ 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>(PerceptionDepthFrameSourceAddedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::PerceptionDepthFrameSourceAddedEventArgs^ UnwrapPerceptionDepthFrameSourceAddedEventArgs(Local<Value> value) {
     return PerceptionDepthFrameSourceAddedEventArgs::Unwrap<PerceptionDepthFrameSourceAddedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPerceptionDepthFrameSourceAddedEventArgs(Local<Object> exports) {
    PerceptionDepthFrameSourceAddedEventArgs::Init(exports);
  }

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





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

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



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

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

    private:

      PerceptionDepthFrameSourceRemovedEventArgs(::Windows::Devices::Perception::PerceptionDepthFrameSourceRemovedEventArgs^ 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::Devices::Perception::PerceptionDepthFrameSourceRemovedEventArgs^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSourceRemovedEventArgs^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Devices::Perception::PerceptionDepthFrameSource^ result = wrapper->_instance->FrameSource;
        info.GetReturnValue().Set(WrapPerceptionDepthFrameSource(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Devices::Perception::PerceptionDepthFrameSourceRemovedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPerceptionDepthFrameSourceRemovedEventArgs(::Windows::Devices::Perception::PerceptionDepthFrameSourceRemovedEventArgs^ wintRtInstance);
      friend ::Windows::Devices::Perception::PerceptionDepthFrameSourceRemovedEventArgs^ UnwrapPerceptionDepthFrameSourceRemovedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> PerceptionDepthFrameSourceRemovedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapPerceptionDepthFrameSourceRemovedEventArgs(::Windows::Devices::Perception::PerceptionDepthFrameSourceRemovedEventArgs^ 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>(PerceptionDepthFrameSourceRemovedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::PerceptionDepthFrameSourceRemovedEventArgs^ UnwrapPerceptionDepthFrameSourceRemovedEventArgs(Local<Value> value) {
     return PerceptionDepthFrameSourceRemovedEventArgs::Unwrap<PerceptionDepthFrameSourceRemovedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPerceptionDepthFrameSourceRemovedEventArgs(Local<Object> exports) {
    PerceptionDepthFrameSourceRemovedEventArgs::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "start", Start);
            Nan::SetPrototypeMethod(localRef, "stop", Stop);
          


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

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

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



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

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

    private:

      PerceptionInfraredFrameSourceWatcher(::Windows::Devices::Perception::PerceptionInfraredFrameSourceWatcher^ 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::Devices::Perception::PerceptionInfraredFrameSourceWatcher^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSourceWatcher^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSourceWatcher^>(info.This())) {
        return;
      }

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

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



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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSourceWatcher^>(info.This())) {
        return;
      }

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

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


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

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"enumerationCompleted", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSourceWatcher^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionInfraredFrameSourceWatcher *wrapper = PerceptionInfraredFrameSourceWatcher::Unwrap<PerceptionInfraredFrameSourceWatcher>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->EnumerationCompleted::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionInfraredFrameSourceWatcher^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionInfraredFrameSourceWatcher^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionInfraredFrameSourceWatcher(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"sourceAdded", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSourceWatcher^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionInfraredFrameSourceWatcher *wrapper = PerceptionInfraredFrameSourceWatcher::Unwrap<PerceptionInfraredFrameSourceWatcher>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->SourceAdded::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionInfraredFrameSourceWatcher^, ::Windows::Devices::Perception::PerceptionInfraredFrameSourceAddedEventArgs^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionInfraredFrameSourceWatcher^ arg0, ::Windows::Devices::Perception::PerceptionInfraredFrameSourceAddedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionInfraredFrameSourceWatcher(arg0);
                  wrappedArg1 = WrapPerceptionInfraredFrameSourceAddedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"sourceRemoved", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSourceWatcher^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionInfraredFrameSourceWatcher *wrapper = PerceptionInfraredFrameSourceWatcher::Unwrap<PerceptionInfraredFrameSourceWatcher>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->SourceRemoved::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionInfraredFrameSourceWatcher^, ::Windows::Devices::Perception::PerceptionInfraredFrameSourceRemovedEventArgs^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionInfraredFrameSourceWatcher^ arg0, ::Windows::Devices::Perception::PerceptionInfraredFrameSourceRemovedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionInfraredFrameSourceWatcher(arg0);
                  wrappedArg1 = WrapPerceptionInfraredFrameSourceRemovedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"stopped", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSourceWatcher^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionInfraredFrameSourceWatcher *wrapper = PerceptionInfraredFrameSourceWatcher::Unwrap<PerceptionInfraredFrameSourceWatcher>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->Stopped::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionInfraredFrameSourceWatcher^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionInfraredFrameSourceWatcher^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionInfraredFrameSourceWatcher(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
 else  {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Value> tokenMapVal = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());
      Local<Object> tokenMap;

      if (tokenMapVal.IsEmpty() || Nan::Equals(tokenMapVal, Undefined()).FromMaybe(false)) {
        tokenMap = Nan::New<Object>();
        NodeRT::Utils::SetHiddenValueWithObject(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked(), tokenMap);
      } else {
        tokenMap = Nan::To<Object>(tokenMapVal).ToLocalChecked();
      }

      Nan::Set(tokenMap, info[0], CreateOpaqueWrapper(::Windows::Foundation::PropertyValue::CreateInt64(registrationToken.Value)));
    }

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

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected a string and a callback")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      if ((!NodeRT::Utils::CaseInsenstiveEquals(L"enumerationCompleted", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"sourceAdded", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"sourceRemoved", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"stopped", str))) {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Function> callback = info[1].As<Function>();
      Local<Value> tokenMap = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());

      if (tokenMap.IsEmpty() || Nan::Equals(tokenMap, Undefined()).FromMaybe(false)) {
        return;
      }

      Local<Value> opaqueWrapperObj =  Nan::Get(Nan::To<Object>(tokenMap).ToLocalChecked(), info[0]).ToLocalChecked();

      if (opaqueWrapperObj.IsEmpty() || Nan::Equals(opaqueWrapperObj,Undefined()).FromMaybe(false)) {
        return;
      }

      OpaqueWrapper *opaqueWrapper = OpaqueWrapper::Unwrap<OpaqueWrapper>(opaqueWrapperObj.As<Object>());

      long long tokenValue = (long long) opaqueWrapper->GetObjectInstance();
      ::Windows::Foundation::EventRegistrationToken registrationToken;
      registrationToken.Value = tokenValue;

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"enumerationCompleted", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSourceWatcher^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionInfraredFrameSourceWatcher *wrapper = PerceptionInfraredFrameSourceWatcher::Unwrap<PerceptionInfraredFrameSourceWatcher>(info.This());
          wrapper->_instance->EnumerationCompleted::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"sourceAdded", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSourceWatcher^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionInfraredFrameSourceWatcher *wrapper = PerceptionInfraredFrameSourceWatcher::Unwrap<PerceptionInfraredFrameSourceWatcher>(info.This());
          wrapper->_instance->SourceAdded::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"sourceRemoved", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSourceWatcher^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionInfraredFrameSourceWatcher *wrapper = PerceptionInfraredFrameSourceWatcher::Unwrap<PerceptionInfraredFrameSourceWatcher>(info.This());
          wrapper->_instance->SourceRemoved::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"stopped", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSourceWatcher^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionInfraredFrameSourceWatcher *wrapper = PerceptionInfraredFrameSourceWatcher::Unwrap<PerceptionInfraredFrameSourceWatcher>(info.This());
          wrapper->_instance->Stopped::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

      Nan::Delete(Nan::To<Object>(tokenMap).ToLocalChecked(), Nan::To<String>(info[0]).ToLocalChecked());
    }
    private:
      ::Windows::Devices::Perception::PerceptionInfraredFrameSourceWatcher^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPerceptionInfraredFrameSourceWatcher(::Windows::Devices::Perception::PerceptionInfraredFrameSourceWatcher^ wintRtInstance);
      friend ::Windows::Devices::Perception::PerceptionInfraredFrameSourceWatcher^ UnwrapPerceptionInfraredFrameSourceWatcher(Local<Value> value);
  };

  Persistent<FunctionTemplate> PerceptionInfraredFrameSourceWatcher::s_constructorTemplate;

  v8::Local<v8::Value> WrapPerceptionInfraredFrameSourceWatcher(::Windows::Devices::Perception::PerceptionInfraredFrameSourceWatcher^ 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>(PerceptionInfraredFrameSourceWatcher::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::PerceptionInfraredFrameSourceWatcher^ UnwrapPerceptionInfraredFrameSourceWatcher(Local<Value> value) {
     return PerceptionInfraredFrameSourceWatcher::Unwrap<PerceptionInfraredFrameSourceWatcher>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPerceptionInfraredFrameSourceWatcher(Local<Object> exports) {
    PerceptionInfraredFrameSourceWatcher::Init(exports);
  }

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





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

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



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

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

    private:

      PerceptionInfraredFrameSourceAddedEventArgs(::Windows::Devices::Perception::PerceptionInfraredFrameSourceAddedEventArgs^ 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::Devices::Perception::PerceptionInfraredFrameSourceAddedEventArgs^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSourceAddedEventArgs^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Devices::Perception::PerceptionInfraredFrameSource^ result = wrapper->_instance->FrameSource;
        info.GetReturnValue().Set(WrapPerceptionInfraredFrameSource(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Devices::Perception::PerceptionInfraredFrameSourceAddedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPerceptionInfraredFrameSourceAddedEventArgs(::Windows::Devices::Perception::PerceptionInfraredFrameSourceAddedEventArgs^ wintRtInstance);
      friend ::Windows::Devices::Perception::PerceptionInfraredFrameSourceAddedEventArgs^ UnwrapPerceptionInfraredFrameSourceAddedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> PerceptionInfraredFrameSourceAddedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapPerceptionInfraredFrameSourceAddedEventArgs(::Windows::Devices::Perception::PerceptionInfraredFrameSourceAddedEventArgs^ 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>(PerceptionInfraredFrameSourceAddedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::PerceptionInfraredFrameSourceAddedEventArgs^ UnwrapPerceptionInfraredFrameSourceAddedEventArgs(Local<Value> value) {
     return PerceptionInfraredFrameSourceAddedEventArgs::Unwrap<PerceptionInfraredFrameSourceAddedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPerceptionInfraredFrameSourceAddedEventArgs(Local<Object> exports) {
    PerceptionInfraredFrameSourceAddedEventArgs::Init(exports);
  }

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





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

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



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

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

    private:

      PerceptionInfraredFrameSourceRemovedEventArgs(::Windows::Devices::Perception::PerceptionInfraredFrameSourceRemovedEventArgs^ 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::Devices::Perception::PerceptionInfraredFrameSourceRemovedEventArgs^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSourceRemovedEventArgs^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Devices::Perception::PerceptionInfraredFrameSource^ result = wrapper->_instance->FrameSource;
        info.GetReturnValue().Set(WrapPerceptionInfraredFrameSource(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Devices::Perception::PerceptionInfraredFrameSourceRemovedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPerceptionInfraredFrameSourceRemovedEventArgs(::Windows::Devices::Perception::PerceptionInfraredFrameSourceRemovedEventArgs^ wintRtInstance);
      friend ::Windows::Devices::Perception::PerceptionInfraredFrameSourceRemovedEventArgs^ UnwrapPerceptionInfraredFrameSourceRemovedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> PerceptionInfraredFrameSourceRemovedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapPerceptionInfraredFrameSourceRemovedEventArgs(::Windows::Devices::Perception::PerceptionInfraredFrameSourceRemovedEventArgs^ 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>(PerceptionInfraredFrameSourceRemovedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::PerceptionInfraredFrameSourceRemovedEventArgs^ UnwrapPerceptionInfraredFrameSourceRemovedEventArgs(Local<Value> value) {
     return PerceptionInfraredFrameSourceRemovedEventArgs::Unwrap<PerceptionInfraredFrameSourceRemovedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPerceptionInfraredFrameSourceRemovedEventArgs(Local<Object> exports) {
    PerceptionInfraredFrameSourceRemovedEventArgs::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "acquireControlSession", AcquireControlSession);
            Nan::SetPrototypeMethod(localRef, "canControlIndependentlyFrom", CanControlIndependentlyFrom);
            Nan::SetPrototypeMethod(localRef, "isCorrelatedWith", IsCorrelatedWith);
            Nan::SetPrototypeMethod(localRef, "tryGetTransformTo", TryGetTransformTo);
            Nan::SetPrototypeMethod(localRef, "openReader", OpenReader);
          

          
            Nan::SetPrototypeMethod(localRef, "tryGetDepthCorrelatedCameraIntrinsicsAsync", TryGetDepthCorrelatedCameraIntrinsicsAsync);
            Nan::SetPrototypeMethod(localRef, "tryGetDepthCorrelatedCoordinateMapperAsync", TryGetDepthCorrelatedCoordinateMapperAsync);
            Nan::SetPrototypeMethod(localRef, "trySetVideoProfileAsync", TrySetVideoProfileAsync);
          

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

          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("active").ToLocalChecked(), ActiveGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("available").ToLocalChecked(), AvailableGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("availableVideoProfiles").ToLocalChecked(), AvailableVideoProfilesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("cameraIntrinsics").ToLocalChecked(), CameraIntrinsicsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("deviceKind").ToLocalChecked(), DeviceKindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("displayName").ToLocalChecked(), DisplayNameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("id").ToLocalChecked(), IdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isControlled").ToLocalChecked(), IsControlledGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("properties").ToLocalChecked(), PropertiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("supportedVideoProfiles").ToLocalChecked(), SupportedVideoProfilesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoProfile").ToLocalChecked(), VideoProfileGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("deviceId").ToLocalChecked(), DeviceIdGetter);

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

        Nan::SetMethod(constructor, "createWatcher", CreateWatcher);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(FindAllAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("findAllAsync").ToLocalChecked(), func);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(FromIdAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("fromIdAsync").ToLocalChecked(), func);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(RequestAccessAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("requestAccessAsync").ToLocalChecked(), func);


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

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

    private:

      PerceptionColorFrameSource(::Windows::Devices::Perception::PerceptionColorFrameSource^ 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::Devices::Perception::PerceptionColorFrameSource^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Devices::Perception::PerceptionDepthCorrelatedCameraIntrinsics^>^ op;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Devices::Perception::PerceptionDepthCorrelatedCoordinateMapper^>^ op;


      if (info.Length() == 3
        && info[0]->IsString()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info[1]))
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Devices::Perception::PerceptionDepthFrameSource^ arg1 = UnwrapPerceptionDepthFrameSource(info[1]);
          
          op = wrapper->_instance->TryGetDepthCorrelatedCoordinateMapperAsync(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::Devices::Perception::PerceptionDepthCorrelatedCoordinateMapper^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Devices::Perception::PerceptionFrameSourcePropertyChangeResult^>^ op;


      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionControlSession^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionVideoProfile^>(info[1]))
      {
        try
        {
          ::Windows::Devices::Perception::PerceptionControlSession^ arg0 = UnwrapPerceptionControlSession(info[0]);
          ::Windows::Devices::Perception::PerceptionVideoProfile^ arg1 = UnwrapPerceptionVideoProfile(info[1]);
          
          op = wrapper->_instance->TrySetVideoProfileAsync(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::Devices::Perception::PerceptionFrameSourcePropertyChangeResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Devices::Perception::PerceptionControlSession^ result;
          result = wrapper->_instance->AcquireControlSession();
          info.GetReturnValue().Set(WrapPerceptionControlSession(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 CanControlIndependentlyFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(info.This())) {
        return;
      }

      PerceptionColorFrameSource *wrapper = PerceptionColorFrameSource::Unwrap<PerceptionColorFrameSource>(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->CanControlIndependentlyFrom(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 IsCorrelatedWith(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(info.This())) {
        return;
      }

      PerceptionColorFrameSource *wrapper = PerceptionColorFrameSource::Unwrap<PerceptionColorFrameSource>(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->IsCorrelatedWith(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 TryGetTransformTo(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(info.This())) {
        return;
      }

      PerceptionColorFrameSource *wrapper = PerceptionColorFrameSource::Unwrap<PerceptionColorFrameSource>(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::Numerics::Matrix4x4 arg1;
          
          bool result;
          result = wrapper->_instance->TryGetTransformTo(arg0, &arg1);
          Local<Object> resObj = Nan::New<Object>();
          Nan::Set(resObj, Nan::New<String>("boolean").ToLocalChecked(), Nan::New<Boolean>(result));
          Nan::Set(resObj, Nan::New<String>("result").ToLocalChecked(), Matrix4x4ToJsObject(arg1));
          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 OpenReader(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Devices::Perception::PerceptionColorFrameReader^ result;
          result = wrapper->_instance->OpenReader();
          info.GetReturnValue().Set(WrapPerceptionColorFrameReader(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 FindAllAsync(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::Foundation::Collections::IVectorView<::Windows::Devices::Perception::PerceptionColorFrameSource^>^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = ::Windows::Devices::Perception::PerceptionColorFrameSource::FindAllAsync();
        } catch (Platform::Exception ^exception) {
            NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
            return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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


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

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

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

    static void FromIdAsync(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::Devices::Perception::PerceptionColorFrameSource^>^ op;


      if (info.Length() == 2
          && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
            
          op = ::Windows::Devices::Perception::PerceptionColorFrameSource::FromIdAsync(arg0);
        } catch (Platform::Exception ^exception) {
            NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
            return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapPerceptionColorFrameSource(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 RequestAccessAsync(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::Devices::Perception::PerceptionFrameSourceAccessStatus>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = ::Windows::Devices::Perception::PerceptionColorFrameSource::RequestAccessAsync();
        } catch (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::Devices::Perception::PerceptionFrameSourceAccessStatus> t)
      {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = Nan::New<Integer>(static_cast<int>(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 CreateWatcher(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Devices::Perception::PerceptionColorFrameSourceWatcher^ result;
          result = ::Windows::Devices::Perception::PerceptionColorFrameSource::CreateWatcher();
          info.GetReturnValue().Set(WrapPerceptionColorFrameSourceWatcher(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 ActiveGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Devices::Perception::PerceptionVideoProfile^>^ result = wrapper->_instance->AvailableVideoProfiles;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Devices::Perception::PerceptionVideoProfile^>::CreateVectorViewWrapper(result, 
            [](::Windows::Devices::Perception::PerceptionVideoProfile^ val) -> Local<Value> {
              return WrapPerceptionVideoProfile(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionVideoProfile^>(value);
            },
            [](Local<Value> value) -> ::Windows::Devices::Perception::PerceptionVideoProfile^ {
              return UnwrapPerceptionVideoProfile(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CameraIntrinsicsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IMapView<::Platform::String^, ::Platform::Object^>^ result = wrapper->_instance->Properties;
        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 SupportedVideoProfilesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Devices::Perception::PerceptionVideoProfile^>^ result = wrapper->_instance->SupportedVideoProfiles;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Devices::Perception::PerceptionVideoProfile^>::CreateVectorViewWrapper(result, 
            [](::Windows::Devices::Perception::PerceptionVideoProfile^ val) -> Local<Value> {
              return WrapPerceptionVideoProfile(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionVideoProfile^>(value);
            },
            [](Local<Value> value) -> ::Windows::Devices::Perception::PerceptionVideoProfile^ {
              return UnwrapPerceptionVideoProfile(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VideoProfileGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Devices::Perception::PerceptionVideoProfile^ result = wrapper->_instance->VideoProfile;
        info.GetReturnValue().Set(WrapPerceptionVideoProfile(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DeviceIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(info.This())) {
        return;
      }

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

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


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

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"activeChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionColorFrameSource *wrapper = PerceptionColorFrameSource::Unwrap<PerceptionColorFrameSource>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->ActiveChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionColorFrameSource^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionColorFrameSource^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionColorFrameSource(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"availableChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionColorFrameSource *wrapper = PerceptionColorFrameSource::Unwrap<PerceptionColorFrameSource>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->AvailableChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionColorFrameSource^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionColorFrameSource^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionColorFrameSource(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"cameraIntrinsicsChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionColorFrameSource *wrapper = PerceptionColorFrameSource::Unwrap<PerceptionColorFrameSource>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->CameraIntrinsicsChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionColorFrameSource^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionColorFrameSource^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionColorFrameSource(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"propertiesChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionColorFrameSource *wrapper = PerceptionColorFrameSource::Unwrap<PerceptionColorFrameSource>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PropertiesChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionColorFrameSource^, ::Windows::Devices::Perception::PerceptionFrameSourcePropertiesChangedEventArgs^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionColorFrameSource^ arg0, ::Windows::Devices::Perception::PerceptionFrameSourcePropertiesChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionColorFrameSource(arg0);
                  wrappedArg1 = WrapPerceptionFrameSourcePropertiesChangedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"videoProfileChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionColorFrameSource *wrapper = PerceptionColorFrameSource::Unwrap<PerceptionColorFrameSource>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->VideoProfileChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionColorFrameSource^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionColorFrameSource^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionColorFrameSource(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
 else  {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Value> tokenMapVal = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());
      Local<Object> tokenMap;

      if (tokenMapVal.IsEmpty() || Nan::Equals(tokenMapVal, Undefined()).FromMaybe(false)) {
        tokenMap = Nan::New<Object>();
        NodeRT::Utils::SetHiddenValueWithObject(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked(), tokenMap);
      } else {
        tokenMap = Nan::To<Object>(tokenMapVal).ToLocalChecked();
      }

      Nan::Set(tokenMap, info[0], CreateOpaqueWrapper(::Windows::Foundation::PropertyValue::CreateInt64(registrationToken.Value)));
    }

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

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected a string and a callback")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      if ((!NodeRT::Utils::CaseInsenstiveEquals(L"activeChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"availableChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"cameraIntrinsicsChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"propertiesChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"videoProfileChanged", str))) {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Function> callback = info[1].As<Function>();
      Local<Value> tokenMap = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());

      if (tokenMap.IsEmpty() || Nan::Equals(tokenMap, Undefined()).FromMaybe(false)) {
        return;
      }

      Local<Value> opaqueWrapperObj =  Nan::Get(Nan::To<Object>(tokenMap).ToLocalChecked(), info[0]).ToLocalChecked();

      if (opaqueWrapperObj.IsEmpty() || Nan::Equals(opaqueWrapperObj,Undefined()).FromMaybe(false)) {
        return;
      }

      OpaqueWrapper *opaqueWrapper = OpaqueWrapper::Unwrap<OpaqueWrapper>(opaqueWrapperObj.As<Object>());

      long long tokenValue = (long long) opaqueWrapper->GetObjectInstance();
      ::Windows::Foundation::EventRegistrationToken registrationToken;
      registrationToken.Value = tokenValue;

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"activeChanged", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionColorFrameSource *wrapper = PerceptionColorFrameSource::Unwrap<PerceptionColorFrameSource>(info.This());
          wrapper->_instance->ActiveChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"availableChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionColorFrameSource *wrapper = PerceptionColorFrameSource::Unwrap<PerceptionColorFrameSource>(info.This());
          wrapper->_instance->AvailableChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"cameraIntrinsicsChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionColorFrameSource *wrapper = PerceptionColorFrameSource::Unwrap<PerceptionColorFrameSource>(info.This());
          wrapper->_instance->CameraIntrinsicsChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"propertiesChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionColorFrameSource *wrapper = PerceptionColorFrameSource::Unwrap<PerceptionColorFrameSource>(info.This());
          wrapper->_instance->PropertiesChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"videoProfileChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameSource^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionColorFrameSource *wrapper = PerceptionColorFrameSource::Unwrap<PerceptionColorFrameSource>(info.This());
          wrapper->_instance->VideoProfileChanged::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

      Nan::Delete(Nan::To<Object>(tokenMap).ToLocalChecked(), Nan::To<String>(info[0]).ToLocalChecked());
    }
    private:
      ::Windows::Devices::Perception::PerceptionColorFrameSource^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPerceptionColorFrameSource(::Windows::Devices::Perception::PerceptionColorFrameSource^ wintRtInstance);
      friend ::Windows::Devices::Perception::PerceptionColorFrameSource^ UnwrapPerceptionColorFrameSource(Local<Value> value);
  };

  Persistent<FunctionTemplate> PerceptionColorFrameSource::s_constructorTemplate;

  v8::Local<v8::Value> WrapPerceptionColorFrameSource(::Windows::Devices::Perception::PerceptionColorFrameSource^ 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>(PerceptionColorFrameSource::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::PerceptionColorFrameSource^ UnwrapPerceptionColorFrameSource(Local<Value> value) {
     return PerceptionColorFrameSource::Unwrap<PerceptionColorFrameSource>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPerceptionColorFrameSource(Local<Object> exports) {
    PerceptionColorFrameSource::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "acquireControlSession", AcquireControlSession);
            Nan::SetPrototypeMethod(localRef, "canControlIndependentlyFrom", CanControlIndependentlyFrom);
            Nan::SetPrototypeMethod(localRef, "isCorrelatedWith", IsCorrelatedWith);
            Nan::SetPrototypeMethod(localRef, "tryGetTransformTo", TryGetTransformTo);
            Nan::SetPrototypeMethod(localRef, "openReader", OpenReader);
          

          
            Nan::SetPrototypeMethod(localRef, "tryGetDepthCorrelatedCameraIntrinsicsAsync", TryGetDepthCorrelatedCameraIntrinsicsAsync);
            Nan::SetPrototypeMethod(localRef, "tryGetDepthCorrelatedCoordinateMapperAsync", TryGetDepthCorrelatedCoordinateMapperAsync);
            Nan::SetPrototypeMethod(localRef, "trySetVideoProfileAsync", TrySetVideoProfileAsync);
          

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

          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("active").ToLocalChecked(), ActiveGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("available").ToLocalChecked(), AvailableGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("availableVideoProfiles").ToLocalChecked(), AvailableVideoProfilesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("cameraIntrinsics").ToLocalChecked(), CameraIntrinsicsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("deviceKind").ToLocalChecked(), DeviceKindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("displayName").ToLocalChecked(), DisplayNameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("id").ToLocalChecked(), IdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isControlled").ToLocalChecked(), IsControlledGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("properties").ToLocalChecked(), PropertiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("supportedVideoProfiles").ToLocalChecked(), SupportedVideoProfilesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoProfile").ToLocalChecked(), VideoProfileGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("deviceId").ToLocalChecked(), DeviceIdGetter);

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

        Nan::SetMethod(constructor, "createWatcher", CreateWatcher);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(FindAllAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("findAllAsync").ToLocalChecked(), func);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(FromIdAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("fromIdAsync").ToLocalChecked(), func);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(RequestAccessAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("requestAccessAsync").ToLocalChecked(), func);


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

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

    private:

      PerceptionDepthFrameSource(::Windows::Devices::Perception::PerceptionDepthFrameSource^ 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::Devices::Perception::PerceptionDepthFrameSource^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Devices::Perception::PerceptionDepthCorrelatedCameraIntrinsics^>^ op;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Devices::Perception::PerceptionDepthCorrelatedCoordinateMapper^>^ op;


      if (info.Length() == 3
        && info[0]->IsString()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info[1]))
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Devices::Perception::PerceptionDepthFrameSource^ arg1 = UnwrapPerceptionDepthFrameSource(info[1]);
          
          op = wrapper->_instance->TryGetDepthCorrelatedCoordinateMapperAsync(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::Devices::Perception::PerceptionDepthCorrelatedCoordinateMapper^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Devices::Perception::PerceptionFrameSourcePropertyChangeResult^>^ op;


      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionControlSession^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionVideoProfile^>(info[1]))
      {
        try
        {
          ::Windows::Devices::Perception::PerceptionControlSession^ arg0 = UnwrapPerceptionControlSession(info[0]);
          ::Windows::Devices::Perception::PerceptionVideoProfile^ arg1 = UnwrapPerceptionVideoProfile(info[1]);
          
          op = wrapper->_instance->TrySetVideoProfileAsync(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::Devices::Perception::PerceptionFrameSourcePropertyChangeResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Devices::Perception::PerceptionControlSession^ result;
          result = wrapper->_instance->AcquireControlSession();
          info.GetReturnValue().Set(WrapPerceptionControlSession(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 CanControlIndependentlyFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info.This())) {
        return;
      }

      PerceptionDepthFrameSource *wrapper = PerceptionDepthFrameSource::Unwrap<PerceptionDepthFrameSource>(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->CanControlIndependentlyFrom(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 IsCorrelatedWith(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info.This())) {
        return;
      }

      PerceptionDepthFrameSource *wrapper = PerceptionDepthFrameSource::Unwrap<PerceptionDepthFrameSource>(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->IsCorrelatedWith(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 TryGetTransformTo(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info.This())) {
        return;
      }

      PerceptionDepthFrameSource *wrapper = PerceptionDepthFrameSource::Unwrap<PerceptionDepthFrameSource>(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::Numerics::Matrix4x4 arg1;
          
          bool result;
          result = wrapper->_instance->TryGetTransformTo(arg0, &arg1);
          Local<Object> resObj = Nan::New<Object>();
          Nan::Set(resObj, Nan::New<String>("boolean").ToLocalChecked(), Nan::New<Boolean>(result));
          Nan::Set(resObj, Nan::New<String>("result").ToLocalChecked(), Matrix4x4ToJsObject(arg1));
          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 OpenReader(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Devices::Perception::PerceptionDepthFrameReader^ result;
          result = wrapper->_instance->OpenReader();
          info.GetReturnValue().Set(WrapPerceptionDepthFrameReader(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 FindAllAsync(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::Foundation::Collections::IVectorView<::Windows::Devices::Perception::PerceptionDepthFrameSource^>^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = ::Windows::Devices::Perception::PerceptionDepthFrameSource::FindAllAsync();
        } catch (Platform::Exception ^exception) {
            NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
            return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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


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

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

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

    static void FromIdAsync(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::Devices::Perception::PerceptionDepthFrameSource^>^ op;


      if (info.Length() == 2
          && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
            
          op = ::Windows::Devices::Perception::PerceptionDepthFrameSource::FromIdAsync(arg0);
        } catch (Platform::Exception ^exception) {
            NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
            return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapPerceptionDepthFrameSource(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 RequestAccessAsync(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::Devices::Perception::PerceptionFrameSourceAccessStatus>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = ::Windows::Devices::Perception::PerceptionDepthFrameSource::RequestAccessAsync();
        } catch (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::Devices::Perception::PerceptionFrameSourceAccessStatus> t)
      {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = Nan::New<Integer>(static_cast<int>(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 CreateWatcher(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Devices::Perception::PerceptionDepthFrameSourceWatcher^ result;
          result = ::Windows::Devices::Perception::PerceptionDepthFrameSource::CreateWatcher();
          info.GetReturnValue().Set(WrapPerceptionDepthFrameSourceWatcher(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 ActiveGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Devices::Perception::PerceptionVideoProfile^>^ result = wrapper->_instance->AvailableVideoProfiles;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Devices::Perception::PerceptionVideoProfile^>::CreateVectorViewWrapper(result, 
            [](::Windows::Devices::Perception::PerceptionVideoProfile^ val) -> Local<Value> {
              return WrapPerceptionVideoProfile(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionVideoProfile^>(value);
            },
            [](Local<Value> value) -> ::Windows::Devices::Perception::PerceptionVideoProfile^ {
              return UnwrapPerceptionVideoProfile(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CameraIntrinsicsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IMapView<::Platform::String^, ::Platform::Object^>^ result = wrapper->_instance->Properties;
        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 SupportedVideoProfilesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Devices::Perception::PerceptionVideoProfile^>^ result = wrapper->_instance->SupportedVideoProfiles;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Devices::Perception::PerceptionVideoProfile^>::CreateVectorViewWrapper(result, 
            [](::Windows::Devices::Perception::PerceptionVideoProfile^ val) -> Local<Value> {
              return WrapPerceptionVideoProfile(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionVideoProfile^>(value);
            },
            [](Local<Value> value) -> ::Windows::Devices::Perception::PerceptionVideoProfile^ {
              return UnwrapPerceptionVideoProfile(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VideoProfileGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Devices::Perception::PerceptionVideoProfile^ result = wrapper->_instance->VideoProfile;
        info.GetReturnValue().Set(WrapPerceptionVideoProfile(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DeviceIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info.This())) {
        return;
      }

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

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


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

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"activeChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionDepthFrameSource *wrapper = PerceptionDepthFrameSource::Unwrap<PerceptionDepthFrameSource>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->ActiveChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionDepthFrameSource^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionDepthFrameSource^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionDepthFrameSource(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"availableChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionDepthFrameSource *wrapper = PerceptionDepthFrameSource::Unwrap<PerceptionDepthFrameSource>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->AvailableChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionDepthFrameSource^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionDepthFrameSource^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionDepthFrameSource(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"cameraIntrinsicsChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionDepthFrameSource *wrapper = PerceptionDepthFrameSource::Unwrap<PerceptionDepthFrameSource>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->CameraIntrinsicsChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionDepthFrameSource^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionDepthFrameSource^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionDepthFrameSource(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"propertiesChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionDepthFrameSource *wrapper = PerceptionDepthFrameSource::Unwrap<PerceptionDepthFrameSource>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PropertiesChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionDepthFrameSource^, ::Windows::Devices::Perception::PerceptionFrameSourcePropertiesChangedEventArgs^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionDepthFrameSource^ arg0, ::Windows::Devices::Perception::PerceptionFrameSourcePropertiesChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionDepthFrameSource(arg0);
                  wrappedArg1 = WrapPerceptionFrameSourcePropertiesChangedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"videoProfileChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionDepthFrameSource *wrapper = PerceptionDepthFrameSource::Unwrap<PerceptionDepthFrameSource>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->VideoProfileChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionDepthFrameSource^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionDepthFrameSource^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionDepthFrameSource(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
 else  {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Value> tokenMapVal = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());
      Local<Object> tokenMap;

      if (tokenMapVal.IsEmpty() || Nan::Equals(tokenMapVal, Undefined()).FromMaybe(false)) {
        tokenMap = Nan::New<Object>();
        NodeRT::Utils::SetHiddenValueWithObject(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked(), tokenMap);
      } else {
        tokenMap = Nan::To<Object>(tokenMapVal).ToLocalChecked();
      }

      Nan::Set(tokenMap, info[0], CreateOpaqueWrapper(::Windows::Foundation::PropertyValue::CreateInt64(registrationToken.Value)));
    }

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

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected a string and a callback")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      if ((!NodeRT::Utils::CaseInsenstiveEquals(L"activeChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"availableChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"cameraIntrinsicsChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"propertiesChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"videoProfileChanged", str))) {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Function> callback = info[1].As<Function>();
      Local<Value> tokenMap = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());

      if (tokenMap.IsEmpty() || Nan::Equals(tokenMap, Undefined()).FromMaybe(false)) {
        return;
      }

      Local<Value> opaqueWrapperObj =  Nan::Get(Nan::To<Object>(tokenMap).ToLocalChecked(), info[0]).ToLocalChecked();

      if (opaqueWrapperObj.IsEmpty() || Nan::Equals(opaqueWrapperObj,Undefined()).FromMaybe(false)) {
        return;
      }

      OpaqueWrapper *opaqueWrapper = OpaqueWrapper::Unwrap<OpaqueWrapper>(opaqueWrapperObj.As<Object>());

      long long tokenValue = (long long) opaqueWrapper->GetObjectInstance();
      ::Windows::Foundation::EventRegistrationToken registrationToken;
      registrationToken.Value = tokenValue;

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"activeChanged", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionDepthFrameSource *wrapper = PerceptionDepthFrameSource::Unwrap<PerceptionDepthFrameSource>(info.This());
          wrapper->_instance->ActiveChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"availableChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionDepthFrameSource *wrapper = PerceptionDepthFrameSource::Unwrap<PerceptionDepthFrameSource>(info.This());
          wrapper->_instance->AvailableChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"cameraIntrinsicsChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionDepthFrameSource *wrapper = PerceptionDepthFrameSource::Unwrap<PerceptionDepthFrameSource>(info.This());
          wrapper->_instance->CameraIntrinsicsChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"propertiesChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionDepthFrameSource *wrapper = PerceptionDepthFrameSource::Unwrap<PerceptionDepthFrameSource>(info.This());
          wrapper->_instance->PropertiesChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"videoProfileChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionDepthFrameSource *wrapper = PerceptionDepthFrameSource::Unwrap<PerceptionDepthFrameSource>(info.This());
          wrapper->_instance->VideoProfileChanged::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

      Nan::Delete(Nan::To<Object>(tokenMap).ToLocalChecked(), Nan::To<String>(info[0]).ToLocalChecked());
    }
    private:
      ::Windows::Devices::Perception::PerceptionDepthFrameSource^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPerceptionDepthFrameSource(::Windows::Devices::Perception::PerceptionDepthFrameSource^ wintRtInstance);
      friend ::Windows::Devices::Perception::PerceptionDepthFrameSource^ UnwrapPerceptionDepthFrameSource(Local<Value> value);
  };

  Persistent<FunctionTemplate> PerceptionDepthFrameSource::s_constructorTemplate;

  v8::Local<v8::Value> WrapPerceptionDepthFrameSource(::Windows::Devices::Perception::PerceptionDepthFrameSource^ 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>(PerceptionDepthFrameSource::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::PerceptionDepthFrameSource^ UnwrapPerceptionDepthFrameSource(Local<Value> value) {
     return PerceptionDepthFrameSource::Unwrap<PerceptionDepthFrameSource>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPerceptionDepthFrameSource(Local<Object> exports) {
    PerceptionDepthFrameSource::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "acquireControlSession", AcquireControlSession);
            Nan::SetPrototypeMethod(localRef, "canControlIndependentlyFrom", CanControlIndependentlyFrom);
            Nan::SetPrototypeMethod(localRef, "isCorrelatedWith", IsCorrelatedWith);
            Nan::SetPrototypeMethod(localRef, "tryGetTransformTo", TryGetTransformTo);
            Nan::SetPrototypeMethod(localRef, "openReader", OpenReader);
          

          
            Nan::SetPrototypeMethod(localRef, "tryGetDepthCorrelatedCameraIntrinsicsAsync", TryGetDepthCorrelatedCameraIntrinsicsAsync);
            Nan::SetPrototypeMethod(localRef, "tryGetDepthCorrelatedCoordinateMapperAsync", TryGetDepthCorrelatedCoordinateMapperAsync);
            Nan::SetPrototypeMethod(localRef, "trySetVideoProfileAsync", TrySetVideoProfileAsync);
          

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

          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("active").ToLocalChecked(), ActiveGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("available").ToLocalChecked(), AvailableGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("availableVideoProfiles").ToLocalChecked(), AvailableVideoProfilesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("cameraIntrinsics").ToLocalChecked(), CameraIntrinsicsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("deviceKind").ToLocalChecked(), DeviceKindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("displayName").ToLocalChecked(), DisplayNameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("id").ToLocalChecked(), IdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isControlled").ToLocalChecked(), IsControlledGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("properties").ToLocalChecked(), PropertiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("supportedVideoProfiles").ToLocalChecked(), SupportedVideoProfilesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoProfile").ToLocalChecked(), VideoProfileGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("deviceId").ToLocalChecked(), DeviceIdGetter);

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

        Nan::SetMethod(constructor, "createWatcher", CreateWatcher);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(FindAllAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("findAllAsync").ToLocalChecked(), func);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(FromIdAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("fromIdAsync").ToLocalChecked(), func);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(RequestAccessAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("requestAccessAsync").ToLocalChecked(), func);


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

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

    private:

      PerceptionInfraredFrameSource(::Windows::Devices::Perception::PerceptionInfraredFrameSource^ 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::Devices::Perception::PerceptionInfraredFrameSource^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Devices::Perception::PerceptionDepthCorrelatedCameraIntrinsics^>^ op;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Devices::Perception::PerceptionDepthCorrelatedCoordinateMapper^>^ op;


      if (info.Length() == 3
        && info[0]->IsString()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameSource^>(info[1]))
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Devices::Perception::PerceptionDepthFrameSource^ arg1 = UnwrapPerceptionDepthFrameSource(info[1]);
          
          op = wrapper->_instance->TryGetDepthCorrelatedCoordinateMapperAsync(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::Devices::Perception::PerceptionDepthCorrelatedCoordinateMapper^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Devices::Perception::PerceptionFrameSourcePropertyChangeResult^>^ op;


      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionControlSession^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionVideoProfile^>(info[1]))
      {
        try
        {
          ::Windows::Devices::Perception::PerceptionControlSession^ arg0 = UnwrapPerceptionControlSession(info[0]);
          ::Windows::Devices::Perception::PerceptionVideoProfile^ arg1 = UnwrapPerceptionVideoProfile(info[1]);
          
          op = wrapper->_instance->TrySetVideoProfileAsync(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::Devices::Perception::PerceptionFrameSourcePropertyChangeResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Devices::Perception::PerceptionControlSession^ result;
          result = wrapper->_instance->AcquireControlSession();
          info.GetReturnValue().Set(WrapPerceptionControlSession(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 CanControlIndependentlyFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(info.This())) {
        return;
      }

      PerceptionInfraredFrameSource *wrapper = PerceptionInfraredFrameSource::Unwrap<PerceptionInfraredFrameSource>(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->CanControlIndependentlyFrom(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 IsCorrelatedWith(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(info.This())) {
        return;
      }

      PerceptionInfraredFrameSource *wrapper = PerceptionInfraredFrameSource::Unwrap<PerceptionInfraredFrameSource>(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->IsCorrelatedWith(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 TryGetTransformTo(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(info.This())) {
        return;
      }

      PerceptionInfraredFrameSource *wrapper = PerceptionInfraredFrameSource::Unwrap<PerceptionInfraredFrameSource>(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::Numerics::Matrix4x4 arg1;
          
          bool result;
          result = wrapper->_instance->TryGetTransformTo(arg0, &arg1);
          Local<Object> resObj = Nan::New<Object>();
          Nan::Set(resObj, Nan::New<String>("boolean").ToLocalChecked(), Nan::New<Boolean>(result));
          Nan::Set(resObj, Nan::New<String>("result").ToLocalChecked(), Matrix4x4ToJsObject(arg1));
          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 OpenReader(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Devices::Perception::PerceptionInfraredFrameReader^ result;
          result = wrapper->_instance->OpenReader();
          info.GetReturnValue().Set(WrapPerceptionInfraredFrameReader(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 FindAllAsync(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::Foundation::Collections::IVectorView<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = ::Windows::Devices::Perception::PerceptionInfraredFrameSource::FindAllAsync();
        } catch (Platform::Exception ^exception) {
            NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
            return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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


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

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

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

    static void FromIdAsync(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::Devices::Perception::PerceptionInfraredFrameSource^>^ op;


      if (info.Length() == 2
          && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
            
          op = ::Windows::Devices::Perception::PerceptionInfraredFrameSource::FromIdAsync(arg0);
        } catch (Platform::Exception ^exception) {
            NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
            return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapPerceptionInfraredFrameSource(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 RequestAccessAsync(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::Devices::Perception::PerceptionFrameSourceAccessStatus>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = ::Windows::Devices::Perception::PerceptionInfraredFrameSource::RequestAccessAsync();
        } catch (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::Devices::Perception::PerceptionFrameSourceAccessStatus> t)
      {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = Nan::New<Integer>(static_cast<int>(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 CreateWatcher(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Devices::Perception::PerceptionInfraredFrameSourceWatcher^ result;
          result = ::Windows::Devices::Perception::PerceptionInfraredFrameSource::CreateWatcher();
          info.GetReturnValue().Set(WrapPerceptionInfraredFrameSourceWatcher(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 ActiveGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Devices::Perception::PerceptionVideoProfile^>^ result = wrapper->_instance->AvailableVideoProfiles;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Devices::Perception::PerceptionVideoProfile^>::CreateVectorViewWrapper(result, 
            [](::Windows::Devices::Perception::PerceptionVideoProfile^ val) -> Local<Value> {
              return WrapPerceptionVideoProfile(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionVideoProfile^>(value);
            },
            [](Local<Value> value) -> ::Windows::Devices::Perception::PerceptionVideoProfile^ {
              return UnwrapPerceptionVideoProfile(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CameraIntrinsicsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IMapView<::Platform::String^, ::Platform::Object^>^ result = wrapper->_instance->Properties;
        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 SupportedVideoProfilesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Devices::Perception::PerceptionVideoProfile^>^ result = wrapper->_instance->SupportedVideoProfiles;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Devices::Perception::PerceptionVideoProfile^>::CreateVectorViewWrapper(result, 
            [](::Windows::Devices::Perception::PerceptionVideoProfile^ val) -> Local<Value> {
              return WrapPerceptionVideoProfile(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionVideoProfile^>(value);
            },
            [](Local<Value> value) -> ::Windows::Devices::Perception::PerceptionVideoProfile^ {
              return UnwrapPerceptionVideoProfile(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VideoProfileGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Devices::Perception::PerceptionVideoProfile^ result = wrapper->_instance->VideoProfile;
        info.GetReturnValue().Set(WrapPerceptionVideoProfile(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DeviceIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(info.This())) {
        return;
      }

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

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


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

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"activeChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionInfraredFrameSource *wrapper = PerceptionInfraredFrameSource::Unwrap<PerceptionInfraredFrameSource>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->ActiveChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionInfraredFrameSource^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionInfraredFrameSource^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionInfraredFrameSource(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"availableChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionInfraredFrameSource *wrapper = PerceptionInfraredFrameSource::Unwrap<PerceptionInfraredFrameSource>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->AvailableChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionInfraredFrameSource^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionInfraredFrameSource^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionInfraredFrameSource(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"cameraIntrinsicsChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionInfraredFrameSource *wrapper = PerceptionInfraredFrameSource::Unwrap<PerceptionInfraredFrameSource>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->CameraIntrinsicsChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionInfraredFrameSource^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionInfraredFrameSource^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionInfraredFrameSource(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"propertiesChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionInfraredFrameSource *wrapper = PerceptionInfraredFrameSource::Unwrap<PerceptionInfraredFrameSource>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->PropertiesChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionInfraredFrameSource^, ::Windows::Devices::Perception::PerceptionFrameSourcePropertiesChangedEventArgs^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionInfraredFrameSource^ arg0, ::Windows::Devices::Perception::PerceptionFrameSourcePropertiesChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionInfraredFrameSource(arg0);
                  wrappedArg1 = WrapPerceptionFrameSourcePropertiesChangedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"videoProfileChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionInfraredFrameSource *wrapper = PerceptionInfraredFrameSource::Unwrap<PerceptionInfraredFrameSource>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->VideoProfileChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionInfraredFrameSource^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionInfraredFrameSource^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionInfraredFrameSource(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
 else  {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Value> tokenMapVal = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());
      Local<Object> tokenMap;

      if (tokenMapVal.IsEmpty() || Nan::Equals(tokenMapVal, Undefined()).FromMaybe(false)) {
        tokenMap = Nan::New<Object>();
        NodeRT::Utils::SetHiddenValueWithObject(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked(), tokenMap);
      } else {
        tokenMap = Nan::To<Object>(tokenMapVal).ToLocalChecked();
      }

      Nan::Set(tokenMap, info[0], CreateOpaqueWrapper(::Windows::Foundation::PropertyValue::CreateInt64(registrationToken.Value)));
    }

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

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected a string and a callback")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      if ((!NodeRT::Utils::CaseInsenstiveEquals(L"activeChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"availableChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"cameraIntrinsicsChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"propertiesChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"videoProfileChanged", str))) {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Function> callback = info[1].As<Function>();
      Local<Value> tokenMap = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());

      if (tokenMap.IsEmpty() || Nan::Equals(tokenMap, Undefined()).FromMaybe(false)) {
        return;
      }

      Local<Value> opaqueWrapperObj =  Nan::Get(Nan::To<Object>(tokenMap).ToLocalChecked(), info[0]).ToLocalChecked();

      if (opaqueWrapperObj.IsEmpty() || Nan::Equals(opaqueWrapperObj,Undefined()).FromMaybe(false)) {
        return;
      }

      OpaqueWrapper *opaqueWrapper = OpaqueWrapper::Unwrap<OpaqueWrapper>(opaqueWrapperObj.As<Object>());

      long long tokenValue = (long long) opaqueWrapper->GetObjectInstance();
      ::Windows::Foundation::EventRegistrationToken registrationToken;
      registrationToken.Value = tokenValue;

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"activeChanged", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionInfraredFrameSource *wrapper = PerceptionInfraredFrameSource::Unwrap<PerceptionInfraredFrameSource>(info.This());
          wrapper->_instance->ActiveChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"availableChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionInfraredFrameSource *wrapper = PerceptionInfraredFrameSource::Unwrap<PerceptionInfraredFrameSource>(info.This());
          wrapper->_instance->AvailableChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"cameraIntrinsicsChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionInfraredFrameSource *wrapper = PerceptionInfraredFrameSource::Unwrap<PerceptionInfraredFrameSource>(info.This());
          wrapper->_instance->CameraIntrinsicsChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"propertiesChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionInfraredFrameSource *wrapper = PerceptionInfraredFrameSource::Unwrap<PerceptionInfraredFrameSource>(info.This());
          wrapper->_instance->PropertiesChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"videoProfileChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameSource^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionInfraredFrameSource *wrapper = PerceptionInfraredFrameSource::Unwrap<PerceptionInfraredFrameSource>(info.This());
          wrapper->_instance->VideoProfileChanged::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

      Nan::Delete(Nan::To<Object>(tokenMap).ToLocalChecked(), Nan::To<String>(info[0]).ToLocalChecked());
    }
    private:
      ::Windows::Devices::Perception::PerceptionInfraredFrameSource^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPerceptionInfraredFrameSource(::Windows::Devices::Perception::PerceptionInfraredFrameSource^ wintRtInstance);
      friend ::Windows::Devices::Perception::PerceptionInfraredFrameSource^ UnwrapPerceptionInfraredFrameSource(Local<Value> value);
  };

  Persistent<FunctionTemplate> PerceptionInfraredFrameSource::s_constructorTemplate;

  v8::Local<v8::Value> WrapPerceptionInfraredFrameSource(::Windows::Devices::Perception::PerceptionInfraredFrameSource^ 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>(PerceptionInfraredFrameSource::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::PerceptionInfraredFrameSource^ UnwrapPerceptionInfraredFrameSource(Local<Value> value) {
     return PerceptionInfraredFrameSource::Unwrap<PerceptionInfraredFrameSource>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPerceptionInfraredFrameSource(Local<Object> exports) {
    PerceptionInfraredFrameSource::Init(exports);
  }

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

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

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

          
            Nan::SetPrototypeMethod(localRef, "trySetPropertyAsync", TrySetPropertyAsync);
          

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


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



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

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

    private:

      PerceptionControlSession(::Windows::Devices::Perception::PerceptionControlSession^ 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::Devices::Perception::PerceptionControlSession^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionControlSession^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Devices::Perception::PerceptionFrameSourcePropertyChangeResult^>^ op;


      if (info.Length() == 3
        && 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]));
          
          op = wrapper->_instance->TrySetPropertyAsync(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::Devices::Perception::PerceptionFrameSourcePropertyChangeResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionControlSession^>(info.This())) {
        return;
      }

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

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"controlLost", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionControlSession^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionControlSession *wrapper = PerceptionControlSession::Unwrap<PerceptionControlSession>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->ControlLost::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionControlSession^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionControlSession^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionControlSession(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
 else  {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Value> tokenMapVal = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());
      Local<Object> tokenMap;

      if (tokenMapVal.IsEmpty() || Nan::Equals(tokenMapVal, Undefined()).FromMaybe(false)) {
        tokenMap = Nan::New<Object>();
        NodeRT::Utils::SetHiddenValueWithObject(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked(), tokenMap);
      } else {
        tokenMap = Nan::To<Object>(tokenMapVal).ToLocalChecked();
      }

      Nan::Set(tokenMap, info[0], CreateOpaqueWrapper(::Windows::Foundation::PropertyValue::CreateInt64(registrationToken.Value)));
    }

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

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected a string and a callback")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      if ((!NodeRT::Utils::CaseInsenstiveEquals(L"controlLost", str))) {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Function> callback = info[1].As<Function>();
      Local<Value> tokenMap = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());

      if (tokenMap.IsEmpty() || Nan::Equals(tokenMap, Undefined()).FromMaybe(false)) {
        return;
      }

      Local<Value> opaqueWrapperObj =  Nan::Get(Nan::To<Object>(tokenMap).ToLocalChecked(), info[0]).ToLocalChecked();

      if (opaqueWrapperObj.IsEmpty() || Nan::Equals(opaqueWrapperObj,Undefined()).FromMaybe(false)) {
        return;
      }

      OpaqueWrapper *opaqueWrapper = OpaqueWrapper::Unwrap<OpaqueWrapper>(opaqueWrapperObj.As<Object>());

      long long tokenValue = (long long) opaqueWrapper->GetObjectInstance();
      ::Windows::Foundation::EventRegistrationToken registrationToken;
      registrationToken.Value = tokenValue;

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"controlLost", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionControlSession^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionControlSession *wrapper = PerceptionControlSession::Unwrap<PerceptionControlSession>(info.This());
          wrapper->_instance->ControlLost::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

      Nan::Delete(Nan::To<Object>(tokenMap).ToLocalChecked(), Nan::To<String>(info[0]).ToLocalChecked());
    }
    private:
      ::Windows::Devices::Perception::PerceptionControlSession^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPerceptionControlSession(::Windows::Devices::Perception::PerceptionControlSession^ wintRtInstance);
      friend ::Windows::Devices::Perception::PerceptionControlSession^ UnwrapPerceptionControlSession(Local<Value> value);
  };

  Persistent<FunctionTemplate> PerceptionControlSession::s_constructorTemplate;

  v8::Local<v8::Value> WrapPerceptionControlSession(::Windows::Devices::Perception::PerceptionControlSession^ 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>(PerceptionControlSession::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::PerceptionControlSession^ UnwrapPerceptionControlSession(Local<Value> value) {
     return PerceptionControlSession::Unwrap<PerceptionControlSession>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPerceptionControlSession(Local<Object> exports) {
    PerceptionControlSession::Init(exports);
  }

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





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

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



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

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

    private:

      PerceptionFrameSourcePropertyChangeResult(::Windows::Devices::Perception::PerceptionFrameSourcePropertyChangeResult^ 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::Devices::Perception::PerceptionFrameSourcePropertyChangeResult^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionFrameSourcePropertyChangeResult^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionFrameSourcePropertyChangeResult^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Devices::Perception::PerceptionFrameSourcePropertyChangeResult^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPerceptionFrameSourcePropertyChangeResult(::Windows::Devices::Perception::PerceptionFrameSourcePropertyChangeResult^ wintRtInstance);
      friend ::Windows::Devices::Perception::PerceptionFrameSourcePropertyChangeResult^ UnwrapPerceptionFrameSourcePropertyChangeResult(Local<Value> value);
  };

  Persistent<FunctionTemplate> PerceptionFrameSourcePropertyChangeResult::s_constructorTemplate;

  v8::Local<v8::Value> WrapPerceptionFrameSourcePropertyChangeResult(::Windows::Devices::Perception::PerceptionFrameSourcePropertyChangeResult^ 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>(PerceptionFrameSourcePropertyChangeResult::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::PerceptionFrameSourcePropertyChangeResult^ UnwrapPerceptionFrameSourcePropertyChangeResult(Local<Value> value) {
     return PerceptionFrameSourcePropertyChangeResult::Unwrap<PerceptionFrameSourcePropertyChangeResult>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPerceptionFrameSourcePropertyChangeResult(Local<Object> exports) {
    PerceptionFrameSourcePropertyChangeResult::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("collectionChange").ToLocalChecked(), CollectionChangeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("key").ToLocalChecked(), KeyGetter);

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



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

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

    private:

      PerceptionFrameSourcePropertiesChangedEventArgs(::Windows::Devices::Perception::PerceptionFrameSourcePropertiesChangedEventArgs^ 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::Devices::Perception::PerceptionFrameSourcePropertiesChangedEventArgs^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionFrameSourcePropertiesChangedEventArgs^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionFrameSourcePropertiesChangedEventArgs^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Devices::Perception::PerceptionFrameSourcePropertiesChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPerceptionFrameSourcePropertiesChangedEventArgs(::Windows::Devices::Perception::PerceptionFrameSourcePropertiesChangedEventArgs^ wintRtInstance);
      friend ::Windows::Devices::Perception::PerceptionFrameSourcePropertiesChangedEventArgs^ UnwrapPerceptionFrameSourcePropertiesChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> PerceptionFrameSourcePropertiesChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapPerceptionFrameSourcePropertiesChangedEventArgs(::Windows::Devices::Perception::PerceptionFrameSourcePropertiesChangedEventArgs^ 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>(PerceptionFrameSourcePropertiesChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::PerceptionFrameSourcePropertiesChangedEventArgs^ UnwrapPerceptionFrameSourcePropertiesChangedEventArgs(Local<Value> value) {
     return PerceptionFrameSourcePropertiesChangedEventArgs::Unwrap<PerceptionFrameSourcePropertiesChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPerceptionFrameSourcePropertiesChangedEventArgs(Local<Object> exports) {
    PerceptionFrameSourcePropertiesChangedEventArgs::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "isEqual", IsEqual);
          



          
            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>("frameDuration").ToLocalChecked(), FrameDurationGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("height").ToLocalChecked(), HeightGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("width").ToLocalChecked(), WidthGetter);

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



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

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

    private:

      PerceptionVideoProfile(::Windows::Devices::Perception::PerceptionVideoProfile^ 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::Devices::Perception::PerceptionVideoProfile^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionVideoProfile^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionVideoProfile^>(info[0]))
      {
        try
        {
          ::Windows::Devices::Perception::PerceptionVideoProfile^ arg0 = UnwrapPerceptionVideoProfile(info[0]);
          
          bool result;
          result = wrapper->_instance->IsEqual(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 BitmapAlphaModeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionVideoProfile^>(info.This())) {
        return;
      }

      PerceptionVideoProfile *wrapper = PerceptionVideoProfile::Unwrap<PerceptionVideoProfile>(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::Devices::Perception::PerceptionVideoProfile^>(info.This())) {
        return;
      }

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionVideoProfile^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::TimeSpan result = wrapper->_instance->FrameDuration;
        info.GetReturnValue().Set(Nan::New<Number>(result.Duration/10000.0));
        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::Devices::Perception::PerceptionVideoProfile^>(info.This())) {
        return;
      }

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

      try  {
        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::Devices::Perception::PerceptionVideoProfile^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Devices::Perception::PerceptionVideoProfile^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPerceptionVideoProfile(::Windows::Devices::Perception::PerceptionVideoProfile^ wintRtInstance);
      friend ::Windows::Devices::Perception::PerceptionVideoProfile^ UnwrapPerceptionVideoProfile(Local<Value> value);
  };

  Persistent<FunctionTemplate> PerceptionVideoProfile::s_constructorTemplate;

  v8::Local<v8::Value> WrapPerceptionVideoProfile(::Windows::Devices::Perception::PerceptionVideoProfile^ 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>(PerceptionVideoProfile::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::PerceptionVideoProfile^ UnwrapPerceptionVideoProfile(Local<Value> value) {
     return PerceptionVideoProfile::Unwrap<PerceptionVideoProfile>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPerceptionVideoProfile(Local<Object> exports) {
    PerceptionVideoProfile::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "unprojectPixelAtCorrelatedDepth", UnprojectPixelAtCorrelatedDepth);
            Nan::SetPrototypeMethod(localRef, "unprojectPixelsAtCorrelatedDepth", UnprojectPixelsAtCorrelatedDepth);
          

          
            Nan::SetPrototypeMethod(localRef, "unprojectRegionPixelsAtCorrelatedDepthAsync", UnprojectRegionPixelsAtCorrelatedDepthAsync);
            Nan::SetPrototypeMethod(localRef, "unprojectAllPixelsAtCorrelatedDepthAsync", UnprojectAllPixelsAtCorrelatedDepthAsync);
          



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



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

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

    private:

      PerceptionDepthCorrelatedCameraIntrinsics(::Windows::Devices::Perception::PerceptionDepthCorrelatedCameraIntrinsics^ 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::Devices::Perception::PerceptionDepthCorrelatedCameraIntrinsics^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthCorrelatedCameraIntrinsics^>(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;
      }

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

      ::Windows::Foundation::IAsyncAction^ op;


      if (info.Length() == 4
        && NodeRT::Utils::IsRect(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrame^>(info[1])
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<::Platform::Numerics::Vector3>^>(info[2]) || info[2]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Rect arg0 = NodeRT::Utils::RectFromJs(info[0]);
          ::Windows::Devices::Perception::PerceptionDepthFrame^ arg1 = UnwrapPerceptionDepthFrame(info[1]);
          ::Platform::Array<::Platform::Numerics::Vector3>^ arg2 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<::Platform::Numerics::Vector3>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<::Platform::Numerics::Vector3>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return IsVector3JsObject(value);
                 },
                 [](Local<Value> value) -> ::Platform::Numerics::Vector3 {
                   return Vector3FromJsObject(value);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<::Platform::Numerics::Vector3>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[2]);
          
          op = wrapper->_instance->UnprojectRegionPixelsAtCorrelatedDepthAsync(arg0,arg1,arg2);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthCorrelatedCameraIntrinsics^>(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;
      }

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

      ::Windows::Foundation::IAsyncAction^ op;


      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrame^>(info[0])
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<::Platform::Numerics::Vector3>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Devices::Perception::PerceptionDepthFrame^ arg0 = UnwrapPerceptionDepthFrame(info[0]);
          ::Platform::Array<::Platform::Numerics::Vector3>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<::Platform::Numerics::Vector3>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<::Platform::Numerics::Vector3>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return IsVector3JsObject(value);
                 },
                 [](Local<Value> value) -> ::Platform::Numerics::Vector3 {
                   return Vector3FromJsObject(value);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<::Platform::Numerics::Vector3>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          op = wrapper->_instance->UnprojectAllPixelsAtCorrelatedDepthAsync(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<void> t) {
        try {
          t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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


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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthCorrelatedCameraIntrinsics^>(info.This())) {
        return;
      }

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

      if (info.Length() == 2
        && NodeRT::Utils::IsPoint(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrame^>(info[1]))
      {
        try
        {
          ::Windows::Foundation::Point arg0 = NodeRT::Utils::PointFromJs(info[0]);
          ::Windows::Devices::Perception::PerceptionDepthFrame^ arg1 = UnwrapPerceptionDepthFrame(info[1]);
          
          ::Platform::Numerics::Vector3 result;
          result = wrapper->_instance->UnprojectPixelAtCorrelatedDepth(arg0, arg1);
          info.GetReturnValue().Set(Vector3ToJsObject(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 UnprojectPixelsAtCorrelatedDepth(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Not implemented")));
    }





    private:
      ::Windows::Devices::Perception::PerceptionDepthCorrelatedCameraIntrinsics^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPerceptionDepthCorrelatedCameraIntrinsics(::Windows::Devices::Perception::PerceptionDepthCorrelatedCameraIntrinsics^ wintRtInstance);
      friend ::Windows::Devices::Perception::PerceptionDepthCorrelatedCameraIntrinsics^ UnwrapPerceptionDepthCorrelatedCameraIntrinsics(Local<Value> value);
  };

  Persistent<FunctionTemplate> PerceptionDepthCorrelatedCameraIntrinsics::s_constructorTemplate;

  v8::Local<v8::Value> WrapPerceptionDepthCorrelatedCameraIntrinsics(::Windows::Devices::Perception::PerceptionDepthCorrelatedCameraIntrinsics^ 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>(PerceptionDepthCorrelatedCameraIntrinsics::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::PerceptionDepthCorrelatedCameraIntrinsics^ UnwrapPerceptionDepthCorrelatedCameraIntrinsics(Local<Value> value) {
     return PerceptionDepthCorrelatedCameraIntrinsics::Unwrap<PerceptionDepthCorrelatedCameraIntrinsics>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPerceptionDepthCorrelatedCameraIntrinsics(Local<Object> exports) {
    PerceptionDepthCorrelatedCameraIntrinsics::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "mapPixelToTarget", MapPixelToTarget);
            Nan::SetPrototypeMethod(localRef, "mapPixelsToTarget", MapPixelsToTarget);
          

          
            Nan::SetPrototypeMethod(localRef, "mapRegionOfPixelsToTargetAsync", MapRegionOfPixelsToTargetAsync);
            Nan::SetPrototypeMethod(localRef, "mapAllPixelsToTargetAsync", MapAllPixelsToTargetAsync);
          



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



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

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

    private:

      PerceptionDepthCorrelatedCoordinateMapper(::Windows::Devices::Perception::PerceptionDepthCorrelatedCoordinateMapper^ 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::Devices::Perception::PerceptionDepthCorrelatedCoordinateMapper^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthCorrelatedCoordinateMapper^>(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;
      }

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

      ::Windows::Foundation::IAsyncAction^ op;


      if (info.Length() == 4
        && NodeRT::Utils::IsRect(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrame^>(info[1])
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<::Windows::Foundation::Point>^>(info[2]) || info[2]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Rect arg0 = NodeRT::Utils::RectFromJs(info[0]);
          ::Windows::Devices::Perception::PerceptionDepthFrame^ arg1 = UnwrapPerceptionDepthFrame(info[1]);
          ::Platform::Array<::Windows::Foundation::Point>^ arg2 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<::Windows::Foundation::Point>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<::Windows::Foundation::Point>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsPoint(value);
                 },
                 [](Local<Value> value) -> ::Windows::Foundation::Point {
                   return NodeRT::Utils::PointFromJs(value);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<::Windows::Foundation::Point>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[2]);
          
          op = wrapper->_instance->MapRegionOfPixelsToTargetAsync(arg0,arg1,arg2);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthCorrelatedCoordinateMapper^>(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;
      }

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

      ::Windows::Foundation::IAsyncAction^ op;


      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrame^>(info[0])
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<::Windows::Foundation::Point>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Devices::Perception::PerceptionDepthFrame^ arg0 = UnwrapPerceptionDepthFrame(info[0]);
          ::Platform::Array<::Windows::Foundation::Point>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<::Windows::Foundation::Point>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<::Windows::Foundation::Point>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsPoint(value);
                 },
                 [](Local<Value> value) -> ::Windows::Foundation::Point {
                   return NodeRT::Utils::PointFromJs(value);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<::Windows::Foundation::Point>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          op = wrapper->_instance->MapAllPixelsToTargetAsync(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<void> t) {
        try {
          t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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


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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthCorrelatedCoordinateMapper^>(info.This())) {
        return;
      }

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

      if (info.Length() == 2
        && NodeRT::Utils::IsPoint(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrame^>(info[1]))
      {
        try
        {
          ::Windows::Foundation::Point arg0 = NodeRT::Utils::PointFromJs(info[0]);
          ::Windows::Devices::Perception::PerceptionDepthFrame^ arg1 = UnwrapPerceptionDepthFrame(info[1]);
          
          ::Windows::Foundation::Point result;
          result = wrapper->_instance->MapPixelToTarget(arg0, arg1);
          info.GetReturnValue().Set(NodeRT::Utils::PointToJs(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 MapPixelsToTarget(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Not implemented")));
    }





    private:
      ::Windows::Devices::Perception::PerceptionDepthCorrelatedCoordinateMapper^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPerceptionDepthCorrelatedCoordinateMapper(::Windows::Devices::Perception::PerceptionDepthCorrelatedCoordinateMapper^ wintRtInstance);
      friend ::Windows::Devices::Perception::PerceptionDepthCorrelatedCoordinateMapper^ UnwrapPerceptionDepthCorrelatedCoordinateMapper(Local<Value> value);
  };

  Persistent<FunctionTemplate> PerceptionDepthCorrelatedCoordinateMapper::s_constructorTemplate;

  v8::Local<v8::Value> WrapPerceptionDepthCorrelatedCoordinateMapper(::Windows::Devices::Perception::PerceptionDepthCorrelatedCoordinateMapper^ 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>(PerceptionDepthCorrelatedCoordinateMapper::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::PerceptionDepthCorrelatedCoordinateMapper^ UnwrapPerceptionDepthCorrelatedCoordinateMapper(Local<Value> value) {
     return PerceptionDepthCorrelatedCoordinateMapper::Unwrap<PerceptionDepthCorrelatedCoordinateMapper>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPerceptionDepthCorrelatedCoordinateMapper(Local<Object> exports) {
    PerceptionDepthCorrelatedCoordinateMapper::Init(exports);
  }

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


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


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

          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isPaused").ToLocalChecked(), IsPausedGetter, IsPausedSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("source").ToLocalChecked(), SourceGetter);

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



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

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

    private:

      PerceptionColorFrameReader(::Windows::Devices::Perception::PerceptionColorFrameReader^ 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::Devices::Perception::PerceptionColorFrameReader^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameReader^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Devices::Perception::PerceptionColorFrame^ result;
          result = wrapper->_instance->TryReadLatestFrame();
          info.GetReturnValue().Set(WrapPerceptionColorFrame(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::Devices::Perception::PerceptionColorFrameReader^>(info.This())) {
        return;
      }

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameReader^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->IsPaused;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsPausedSetter(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::Devices::Perception::PerceptionColorFrameReader^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameReader^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Devices::Perception::PerceptionColorFrameSource^ result = wrapper->_instance->Source;
        info.GetReturnValue().Set(WrapPerceptionColorFrameSource(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


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

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"frameArrived", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameReader^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionColorFrameReader *wrapper = PerceptionColorFrameReader::Unwrap<PerceptionColorFrameReader>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->FrameArrived::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionColorFrameReader^, ::Windows::Devices::Perception::PerceptionColorFrameArrivedEventArgs^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionColorFrameReader^ arg0, ::Windows::Devices::Perception::PerceptionColorFrameArrivedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionColorFrameReader(arg0);
                  wrappedArg1 = WrapPerceptionColorFrameArrivedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
 else  {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Value> tokenMapVal = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());
      Local<Object> tokenMap;

      if (tokenMapVal.IsEmpty() || Nan::Equals(tokenMapVal, Undefined()).FromMaybe(false)) {
        tokenMap = Nan::New<Object>();
        NodeRT::Utils::SetHiddenValueWithObject(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked(), tokenMap);
      } else {
        tokenMap = Nan::To<Object>(tokenMapVal).ToLocalChecked();
      }

      Nan::Set(tokenMap, info[0], CreateOpaqueWrapper(::Windows::Foundation::PropertyValue::CreateInt64(registrationToken.Value)));
    }

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

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected a string and a callback")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      if ((!NodeRT::Utils::CaseInsenstiveEquals(L"frameArrived", str))) {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Function> callback = info[1].As<Function>();
      Local<Value> tokenMap = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());

      if (tokenMap.IsEmpty() || Nan::Equals(tokenMap, Undefined()).FromMaybe(false)) {
        return;
      }

      Local<Value> opaqueWrapperObj =  Nan::Get(Nan::To<Object>(tokenMap).ToLocalChecked(), info[0]).ToLocalChecked();

      if (opaqueWrapperObj.IsEmpty() || Nan::Equals(opaqueWrapperObj,Undefined()).FromMaybe(false)) {
        return;
      }

      OpaqueWrapper *opaqueWrapper = OpaqueWrapper::Unwrap<OpaqueWrapper>(opaqueWrapperObj.As<Object>());

      long long tokenValue = (long long) opaqueWrapper->GetObjectInstance();
      ::Windows::Foundation::EventRegistrationToken registrationToken;
      registrationToken.Value = tokenValue;

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"frameArrived", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameReader^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionColorFrameReader *wrapper = PerceptionColorFrameReader::Unwrap<PerceptionColorFrameReader>(info.This());
          wrapper->_instance->FrameArrived::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

      Nan::Delete(Nan::To<Object>(tokenMap).ToLocalChecked(), Nan::To<String>(info[0]).ToLocalChecked());
    }
    private:
      ::Windows::Devices::Perception::PerceptionColorFrameReader^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPerceptionColorFrameReader(::Windows::Devices::Perception::PerceptionColorFrameReader^ wintRtInstance);
      friend ::Windows::Devices::Perception::PerceptionColorFrameReader^ UnwrapPerceptionColorFrameReader(Local<Value> value);
  };

  Persistent<FunctionTemplate> PerceptionColorFrameReader::s_constructorTemplate;

  v8::Local<v8::Value> WrapPerceptionColorFrameReader(::Windows::Devices::Perception::PerceptionColorFrameReader^ 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>(PerceptionColorFrameReader::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::PerceptionColorFrameReader^ UnwrapPerceptionColorFrameReader(Local<Value> value) {
     return PerceptionColorFrameReader::Unwrap<PerceptionColorFrameReader>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPerceptionColorFrameReader(Local<Object> exports) {
    PerceptionColorFrameReader::Init(exports);
  }

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


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


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

          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isPaused").ToLocalChecked(), IsPausedGetter, IsPausedSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("source").ToLocalChecked(), SourceGetter);

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



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

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

    private:

      PerceptionDepthFrameReader(::Windows::Devices::Perception::PerceptionDepthFrameReader^ 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::Devices::Perception::PerceptionDepthFrameReader^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameReader^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Devices::Perception::PerceptionDepthFrame^ result;
          result = wrapper->_instance->TryReadLatestFrame();
          info.GetReturnValue().Set(WrapPerceptionDepthFrame(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::Devices::Perception::PerceptionDepthFrameReader^>(info.This())) {
        return;
      }

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameReader^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->IsPaused;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsPausedSetter(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::Devices::Perception::PerceptionDepthFrameReader^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameReader^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Devices::Perception::PerceptionDepthFrameSource^ result = wrapper->_instance->Source;
        info.GetReturnValue().Set(WrapPerceptionDepthFrameSource(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


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

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"frameArrived", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameReader^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionDepthFrameReader *wrapper = PerceptionDepthFrameReader::Unwrap<PerceptionDepthFrameReader>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->FrameArrived::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionDepthFrameReader^, ::Windows::Devices::Perception::PerceptionDepthFrameArrivedEventArgs^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionDepthFrameReader^ arg0, ::Windows::Devices::Perception::PerceptionDepthFrameArrivedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionDepthFrameReader(arg0);
                  wrappedArg1 = WrapPerceptionDepthFrameArrivedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
 else  {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Value> tokenMapVal = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());
      Local<Object> tokenMap;

      if (tokenMapVal.IsEmpty() || Nan::Equals(tokenMapVal, Undefined()).FromMaybe(false)) {
        tokenMap = Nan::New<Object>();
        NodeRT::Utils::SetHiddenValueWithObject(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked(), tokenMap);
      } else {
        tokenMap = Nan::To<Object>(tokenMapVal).ToLocalChecked();
      }

      Nan::Set(tokenMap, info[0], CreateOpaqueWrapper(::Windows::Foundation::PropertyValue::CreateInt64(registrationToken.Value)));
    }

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

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected a string and a callback")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      if ((!NodeRT::Utils::CaseInsenstiveEquals(L"frameArrived", str))) {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Function> callback = info[1].As<Function>();
      Local<Value> tokenMap = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());

      if (tokenMap.IsEmpty() || Nan::Equals(tokenMap, Undefined()).FromMaybe(false)) {
        return;
      }

      Local<Value> opaqueWrapperObj =  Nan::Get(Nan::To<Object>(tokenMap).ToLocalChecked(), info[0]).ToLocalChecked();

      if (opaqueWrapperObj.IsEmpty() || Nan::Equals(opaqueWrapperObj,Undefined()).FromMaybe(false)) {
        return;
      }

      OpaqueWrapper *opaqueWrapper = OpaqueWrapper::Unwrap<OpaqueWrapper>(opaqueWrapperObj.As<Object>());

      long long tokenValue = (long long) opaqueWrapper->GetObjectInstance();
      ::Windows::Foundation::EventRegistrationToken registrationToken;
      registrationToken.Value = tokenValue;

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"frameArrived", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameReader^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionDepthFrameReader *wrapper = PerceptionDepthFrameReader::Unwrap<PerceptionDepthFrameReader>(info.This());
          wrapper->_instance->FrameArrived::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

      Nan::Delete(Nan::To<Object>(tokenMap).ToLocalChecked(), Nan::To<String>(info[0]).ToLocalChecked());
    }
    private:
      ::Windows::Devices::Perception::PerceptionDepthFrameReader^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPerceptionDepthFrameReader(::Windows::Devices::Perception::PerceptionDepthFrameReader^ wintRtInstance);
      friend ::Windows::Devices::Perception::PerceptionDepthFrameReader^ UnwrapPerceptionDepthFrameReader(Local<Value> value);
  };

  Persistent<FunctionTemplate> PerceptionDepthFrameReader::s_constructorTemplate;

  v8::Local<v8::Value> WrapPerceptionDepthFrameReader(::Windows::Devices::Perception::PerceptionDepthFrameReader^ 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>(PerceptionDepthFrameReader::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::PerceptionDepthFrameReader^ UnwrapPerceptionDepthFrameReader(Local<Value> value) {
     return PerceptionDepthFrameReader::Unwrap<PerceptionDepthFrameReader>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPerceptionDepthFrameReader(Local<Object> exports) {
    PerceptionDepthFrameReader::Init(exports);
  }

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


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


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

          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isPaused").ToLocalChecked(), IsPausedGetter, IsPausedSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("source").ToLocalChecked(), SourceGetter);

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



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

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

    private:

      PerceptionInfraredFrameReader(::Windows::Devices::Perception::PerceptionInfraredFrameReader^ 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::Devices::Perception::PerceptionInfraredFrameReader^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameReader^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Devices::Perception::PerceptionInfraredFrame^ result;
          result = wrapper->_instance->TryReadLatestFrame();
          info.GetReturnValue().Set(WrapPerceptionInfraredFrame(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::Devices::Perception::PerceptionInfraredFrameReader^>(info.This())) {
        return;
      }

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameReader^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->IsPaused;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsPausedSetter(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::Devices::Perception::PerceptionInfraredFrameReader^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameReader^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Devices::Perception::PerceptionInfraredFrameSource^ result = wrapper->_instance->Source;
        info.GetReturnValue().Set(WrapPerceptionInfraredFrameSource(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


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

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"frameArrived", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameReader^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        PerceptionInfraredFrameReader *wrapper = PerceptionInfraredFrameReader::Unwrap<PerceptionInfraredFrameReader>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->FrameArrived::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::Perception::PerceptionInfraredFrameReader^, ::Windows::Devices::Perception::PerceptionInfraredFrameArrivedEventArgs^>(
            [callbackObjPtr](::Windows::Devices::Perception::PerceptionInfraredFrameReader^ arg0, ::Windows::Devices::Perception::PerceptionInfraredFrameArrivedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPerceptionInfraredFrameReader(arg0);
                  wrappedArg1 = WrapPerceptionInfraredFrameArrivedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
 else  {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Value> tokenMapVal = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());
      Local<Object> tokenMap;

      if (tokenMapVal.IsEmpty() || Nan::Equals(tokenMapVal, Undefined()).FromMaybe(false)) {
        tokenMap = Nan::New<Object>();
        NodeRT::Utils::SetHiddenValueWithObject(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked(), tokenMap);
      } else {
        tokenMap = Nan::To<Object>(tokenMapVal).ToLocalChecked();
      }

      Nan::Set(tokenMap, info[0], CreateOpaqueWrapper(::Windows::Foundation::PropertyValue::CreateInt64(registrationToken.Value)));
    }

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

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected a string and a callback")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      if ((!NodeRT::Utils::CaseInsenstiveEquals(L"frameArrived", str))) {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Function> callback = info[1].As<Function>();
      Local<Value> tokenMap = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());

      if (tokenMap.IsEmpty() || Nan::Equals(tokenMap, Undefined()).FromMaybe(false)) {
        return;
      }

      Local<Value> opaqueWrapperObj =  Nan::Get(Nan::To<Object>(tokenMap).ToLocalChecked(), info[0]).ToLocalChecked();

      if (opaqueWrapperObj.IsEmpty() || Nan::Equals(opaqueWrapperObj,Undefined()).FromMaybe(false)) {
        return;
      }

      OpaqueWrapper *opaqueWrapper = OpaqueWrapper::Unwrap<OpaqueWrapper>(opaqueWrapperObj.As<Object>());

      long long tokenValue = (long long) opaqueWrapper->GetObjectInstance();
      ::Windows::Foundation::EventRegistrationToken registrationToken;
      registrationToken.Value = tokenValue;

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"frameArrived", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameReader^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          PerceptionInfraredFrameReader *wrapper = PerceptionInfraredFrameReader::Unwrap<PerceptionInfraredFrameReader>(info.This());
          wrapper->_instance->FrameArrived::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

      Nan::Delete(Nan::To<Object>(tokenMap).ToLocalChecked(), Nan::To<String>(info[0]).ToLocalChecked());
    }
    private:
      ::Windows::Devices::Perception::PerceptionInfraredFrameReader^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPerceptionInfraredFrameReader(::Windows::Devices::Perception::PerceptionInfraredFrameReader^ wintRtInstance);
      friend ::Windows::Devices::Perception::PerceptionInfraredFrameReader^ UnwrapPerceptionInfraredFrameReader(Local<Value> value);
  };

  Persistent<FunctionTemplate> PerceptionInfraredFrameReader::s_constructorTemplate;

  v8::Local<v8::Value> WrapPerceptionInfraredFrameReader(::Windows::Devices::Perception::PerceptionInfraredFrameReader^ 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>(PerceptionInfraredFrameReader::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::PerceptionInfraredFrameReader^ UnwrapPerceptionInfraredFrameReader(Local<Value> value) {
     return PerceptionInfraredFrameReader::Unwrap<PerceptionInfraredFrameReader>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPerceptionInfraredFrameReader(Local<Object> exports) {
    PerceptionInfraredFrameReader::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "tryOpenFrame", TryOpenFrame);
          



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

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



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

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

    private:

      PerceptionColorFrameArrivedEventArgs(::Windows::Devices::Perception::PerceptionColorFrameArrivedEventArgs^ 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::Devices::Perception::PerceptionColorFrameArrivedEventArgs^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameArrivedEventArgs^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Devices::Perception::PerceptionColorFrame^ result;
          result = wrapper->_instance->TryOpenFrame();
          info.GetReturnValue().Set(WrapPerceptionColorFrame(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 RelativeTimeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrameArrivedEventArgs^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::TimeSpan result = wrapper->_instance->RelativeTime;
        info.GetReturnValue().Set(Nan::New<Number>(result.Duration/10000.0));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Devices::Perception::PerceptionColorFrameArrivedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPerceptionColorFrameArrivedEventArgs(::Windows::Devices::Perception::PerceptionColorFrameArrivedEventArgs^ wintRtInstance);
      friend ::Windows::Devices::Perception::PerceptionColorFrameArrivedEventArgs^ UnwrapPerceptionColorFrameArrivedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> PerceptionColorFrameArrivedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapPerceptionColorFrameArrivedEventArgs(::Windows::Devices::Perception::PerceptionColorFrameArrivedEventArgs^ 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>(PerceptionColorFrameArrivedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::PerceptionColorFrameArrivedEventArgs^ UnwrapPerceptionColorFrameArrivedEventArgs(Local<Value> value) {
     return PerceptionColorFrameArrivedEventArgs::Unwrap<PerceptionColorFrameArrivedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPerceptionColorFrameArrivedEventArgs(Local<Object> exports) {
    PerceptionColorFrameArrivedEventArgs::Init(exports);
  }

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


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



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

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



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

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

    private:

      PerceptionColorFrame(::Windows::Devices::Perception::PerceptionColorFrame^ 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::Devices::Perception::PerceptionColorFrame^ winRtInstance;


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

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

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



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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrame^>(info.This())) {
        return;
      }

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionColorFrame^>(info.This())) {
        return;
      }

      PerceptionColorFrame *wrapper = PerceptionColorFrame::Unwrap<PerceptionColorFrame>(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;
      }
    }
      


    private:
      ::Windows::Devices::Perception::PerceptionColorFrame^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPerceptionColorFrame(::Windows::Devices::Perception::PerceptionColorFrame^ wintRtInstance);
      friend ::Windows::Devices::Perception::PerceptionColorFrame^ UnwrapPerceptionColorFrame(Local<Value> value);
  };

  Persistent<FunctionTemplate> PerceptionColorFrame::s_constructorTemplate;

  v8::Local<v8::Value> WrapPerceptionColorFrame(::Windows::Devices::Perception::PerceptionColorFrame^ 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>(PerceptionColorFrame::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::PerceptionColorFrame^ UnwrapPerceptionColorFrame(Local<Value> value) {
     return PerceptionColorFrame::Unwrap<PerceptionColorFrame>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPerceptionColorFrame(Local<Object> exports) {
    PerceptionColorFrame::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "tryOpenFrame", TryOpenFrame);
          



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

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



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

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

    private:

      PerceptionDepthFrameArrivedEventArgs(::Windows::Devices::Perception::PerceptionDepthFrameArrivedEventArgs^ 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::Devices::Perception::PerceptionDepthFrameArrivedEventArgs^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameArrivedEventArgs^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Devices::Perception::PerceptionDepthFrame^ result;
          result = wrapper->_instance->TryOpenFrame();
          info.GetReturnValue().Set(WrapPerceptionDepthFrame(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 RelativeTimeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrameArrivedEventArgs^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::TimeSpan result = wrapper->_instance->RelativeTime;
        info.GetReturnValue().Set(Nan::New<Number>(result.Duration/10000.0));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Devices::Perception::PerceptionDepthFrameArrivedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPerceptionDepthFrameArrivedEventArgs(::Windows::Devices::Perception::PerceptionDepthFrameArrivedEventArgs^ wintRtInstance);
      friend ::Windows::Devices::Perception::PerceptionDepthFrameArrivedEventArgs^ UnwrapPerceptionDepthFrameArrivedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> PerceptionDepthFrameArrivedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapPerceptionDepthFrameArrivedEventArgs(::Windows::Devices::Perception::PerceptionDepthFrameArrivedEventArgs^ 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>(PerceptionDepthFrameArrivedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::PerceptionDepthFrameArrivedEventArgs^ UnwrapPerceptionDepthFrameArrivedEventArgs(Local<Value> value) {
     return PerceptionDepthFrameArrivedEventArgs::Unwrap<PerceptionDepthFrameArrivedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPerceptionDepthFrameArrivedEventArgs(Local<Object> exports) {
    PerceptionDepthFrameArrivedEventArgs::Init(exports);
  }

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


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



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

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



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

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

    private:

      PerceptionDepthFrame(::Windows::Devices::Perception::PerceptionDepthFrame^ 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::Devices::Perception::PerceptionDepthFrame^ winRtInstance;


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

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

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



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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrame^>(info.This())) {
        return;
      }

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionDepthFrame^>(info.This())) {
        return;
      }

      PerceptionDepthFrame *wrapper = PerceptionDepthFrame::Unwrap<PerceptionDepthFrame>(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;
      }
    }
      


    private:
      ::Windows::Devices::Perception::PerceptionDepthFrame^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPerceptionDepthFrame(::Windows::Devices::Perception::PerceptionDepthFrame^ wintRtInstance);
      friend ::Windows::Devices::Perception::PerceptionDepthFrame^ UnwrapPerceptionDepthFrame(Local<Value> value);
  };

  Persistent<FunctionTemplate> PerceptionDepthFrame::s_constructorTemplate;

  v8::Local<v8::Value> WrapPerceptionDepthFrame(::Windows::Devices::Perception::PerceptionDepthFrame^ 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>(PerceptionDepthFrame::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::PerceptionDepthFrame^ UnwrapPerceptionDepthFrame(Local<Value> value) {
     return PerceptionDepthFrame::Unwrap<PerceptionDepthFrame>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPerceptionDepthFrame(Local<Object> exports) {
    PerceptionDepthFrame::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "tryOpenFrame", TryOpenFrame);
          



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

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



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

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

    private:

      PerceptionInfraredFrameArrivedEventArgs(::Windows::Devices::Perception::PerceptionInfraredFrameArrivedEventArgs^ 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::Devices::Perception::PerceptionInfraredFrameArrivedEventArgs^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameArrivedEventArgs^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Devices::Perception::PerceptionInfraredFrame^ result;
          result = wrapper->_instance->TryOpenFrame();
          info.GetReturnValue().Set(WrapPerceptionInfraredFrame(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 RelativeTimeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrameArrivedEventArgs^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::TimeSpan result = wrapper->_instance->RelativeTime;
        info.GetReturnValue().Set(Nan::New<Number>(result.Duration/10000.0));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Devices::Perception::PerceptionInfraredFrameArrivedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPerceptionInfraredFrameArrivedEventArgs(::Windows::Devices::Perception::PerceptionInfraredFrameArrivedEventArgs^ wintRtInstance);
      friend ::Windows::Devices::Perception::PerceptionInfraredFrameArrivedEventArgs^ UnwrapPerceptionInfraredFrameArrivedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> PerceptionInfraredFrameArrivedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapPerceptionInfraredFrameArrivedEventArgs(::Windows::Devices::Perception::PerceptionInfraredFrameArrivedEventArgs^ 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>(PerceptionInfraredFrameArrivedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::PerceptionInfraredFrameArrivedEventArgs^ UnwrapPerceptionInfraredFrameArrivedEventArgs(Local<Value> value) {
     return PerceptionInfraredFrameArrivedEventArgs::Unwrap<PerceptionInfraredFrameArrivedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPerceptionInfraredFrameArrivedEventArgs(Local<Object> exports) {
    PerceptionInfraredFrameArrivedEventArgs::Init(exports);
  }

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


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



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

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



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

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

    private:

      PerceptionInfraredFrame(::Windows::Devices::Perception::PerceptionInfraredFrame^ 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::Devices::Perception::PerceptionInfraredFrame^ winRtInstance;


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

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

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



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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrame^>(info.This())) {
        return;
      }

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Perception::PerceptionInfraredFrame^>(info.This())) {
        return;
      }

      PerceptionInfraredFrame *wrapper = PerceptionInfraredFrame::Unwrap<PerceptionInfraredFrame>(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;
      }
    }
      


    private:
      ::Windows::Devices::Perception::PerceptionInfraredFrame^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPerceptionInfraredFrame(::Windows::Devices::Perception::PerceptionInfraredFrame^ wintRtInstance);
      friend ::Windows::Devices::Perception::PerceptionInfraredFrame^ UnwrapPerceptionInfraredFrame(Local<Value> value);
  };

  Persistent<FunctionTemplate> PerceptionInfraredFrame::s_constructorTemplate;

  v8::Local<v8::Value> WrapPerceptionInfraredFrame(::Windows::Devices::Perception::PerceptionInfraredFrame^ 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>(PerceptionInfraredFrame::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::PerceptionInfraredFrame^ UnwrapPerceptionInfraredFrame(Local<Value> value) {
     return PerceptionInfraredFrame::Unwrap<PerceptionInfraredFrame>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPerceptionInfraredFrame(Local<Object> exports) {
    PerceptionInfraredFrame::Init(exports);
  }

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






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

        Nan::SetAccessor(constructor, Nan::New<String>("deviceModelVersion").ToLocalChecked(), DeviceModelVersionGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("enclosureLocation").ToLocalChecked(), EnclosureLocationGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("frameKind").ToLocalChecked(), FrameKindGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("id").ToLocalChecked(), IdGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("physicalDeviceIds").ToLocalChecked(), PhysicalDeviceIdsGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("deviceId").ToLocalChecked(), DeviceIdGetter);


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

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

    private:

      KnownPerceptionFrameSourceProperties(::Windows::Devices::Perception::KnownPerceptionFrameSourceProperties^ 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::Devices::Perception::KnownPerceptionFrameSourceProperties^ winRtInstance;


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

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

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







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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownPerceptionFrameSourceProperties::DeviceModelVersion;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownPerceptionFrameSourceProperties::EnclosureLocation;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownPerceptionFrameSourceProperties::FrameKind;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownPerceptionFrameSourceProperties::Id;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownPerceptionFrameSourceProperties::PhysicalDeviceIds;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownPerceptionFrameSourceProperties::DeviceId;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    private:
      ::Windows::Devices::Perception::KnownPerceptionFrameSourceProperties^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapKnownPerceptionFrameSourceProperties(::Windows::Devices::Perception::KnownPerceptionFrameSourceProperties^ wintRtInstance);
      friend ::Windows::Devices::Perception::KnownPerceptionFrameSourceProperties^ UnwrapKnownPerceptionFrameSourceProperties(Local<Value> value);
  };

  Persistent<FunctionTemplate> KnownPerceptionFrameSourceProperties::s_constructorTemplate;

  v8::Local<v8::Value> WrapKnownPerceptionFrameSourceProperties(::Windows::Devices::Perception::KnownPerceptionFrameSourceProperties^ 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>(KnownPerceptionFrameSourceProperties::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::KnownPerceptionFrameSourceProperties^ UnwrapKnownPerceptionFrameSourceProperties(Local<Value> value) {
     return KnownPerceptionFrameSourceProperties::Unwrap<KnownPerceptionFrameSourceProperties>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitKnownPerceptionFrameSourceProperties(Local<Object> exports) {
    KnownPerceptionFrameSourceProperties::Init(exports);
  }

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






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

        Nan::SetAccessor(constructor, Nan::New<String>("availableVideoProfiles").ToLocalChecked(), AvailableVideoProfilesGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("cameraIntrinsics").ToLocalChecked(), CameraIntrinsicsGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("isMirrored").ToLocalChecked(), IsMirroredGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("supportedVideoProfiles").ToLocalChecked(), SupportedVideoProfilesGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("videoProfile").ToLocalChecked(), VideoProfileGetter);


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

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

    private:

      KnownPerceptionVideoFrameSourceProperties(::Windows::Devices::Perception::KnownPerceptionVideoFrameSourceProperties^ 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::Devices::Perception::KnownPerceptionVideoFrameSourceProperties^ winRtInstance;


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

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

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







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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownPerceptionVideoFrameSourceProperties::AvailableVideoProfiles;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownPerceptionVideoFrameSourceProperties::CameraIntrinsics;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownPerceptionVideoFrameSourceProperties::IsMirrored;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownPerceptionVideoFrameSourceProperties::SupportedVideoProfiles;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownPerceptionVideoFrameSourceProperties::VideoProfile;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    private:
      ::Windows::Devices::Perception::KnownPerceptionVideoFrameSourceProperties^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapKnownPerceptionVideoFrameSourceProperties(::Windows::Devices::Perception::KnownPerceptionVideoFrameSourceProperties^ wintRtInstance);
      friend ::Windows::Devices::Perception::KnownPerceptionVideoFrameSourceProperties^ UnwrapKnownPerceptionVideoFrameSourceProperties(Local<Value> value);
  };

  Persistent<FunctionTemplate> KnownPerceptionVideoFrameSourceProperties::s_constructorTemplate;

  v8::Local<v8::Value> WrapKnownPerceptionVideoFrameSourceProperties(::Windows::Devices::Perception::KnownPerceptionVideoFrameSourceProperties^ 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>(KnownPerceptionVideoFrameSourceProperties::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::KnownPerceptionVideoFrameSourceProperties^ UnwrapKnownPerceptionVideoFrameSourceProperties(Local<Value> value) {
     return KnownPerceptionVideoFrameSourceProperties::Unwrap<KnownPerceptionVideoFrameSourceProperties>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitKnownPerceptionVideoFrameSourceProperties(Local<Object> exports) {
    KnownPerceptionVideoFrameSourceProperties::Init(exports);
  }

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






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

        Nan::SetAccessor(constructor, Nan::New<String>("activeIlluminationEnabled").ToLocalChecked(), ActiveIlluminationEnabledGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("ambientSubtractionEnabled").ToLocalChecked(), AmbientSubtractionEnabledGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("autoExposureEnabled").ToLocalChecked(), AutoExposureEnabledGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("exposure").ToLocalChecked(), ExposureGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("exposureCompensation").ToLocalChecked(), ExposureCompensationGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("interleavedIlluminationEnabled").ToLocalChecked(), InterleavedIlluminationEnabledGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("structureLightPatternEnabled").ToLocalChecked(), StructureLightPatternEnabledGetter);


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

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

    private:

      KnownPerceptionInfraredFrameSourceProperties(::Windows::Devices::Perception::KnownPerceptionInfraredFrameSourceProperties^ 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::Devices::Perception::KnownPerceptionInfraredFrameSourceProperties^ winRtInstance;


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

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

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







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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownPerceptionInfraredFrameSourceProperties::ActiveIlluminationEnabled;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownPerceptionInfraredFrameSourceProperties::AmbientSubtractionEnabled;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownPerceptionInfraredFrameSourceProperties::AutoExposureEnabled;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownPerceptionInfraredFrameSourceProperties::Exposure;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownPerceptionInfraredFrameSourceProperties::ExposureCompensation;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownPerceptionInfraredFrameSourceProperties::InterleavedIlluminationEnabled;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownPerceptionInfraredFrameSourceProperties::StructureLightPatternEnabled;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    private:
      ::Windows::Devices::Perception::KnownPerceptionInfraredFrameSourceProperties^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapKnownPerceptionInfraredFrameSourceProperties(::Windows::Devices::Perception::KnownPerceptionInfraredFrameSourceProperties^ wintRtInstance);
      friend ::Windows::Devices::Perception::KnownPerceptionInfraredFrameSourceProperties^ UnwrapKnownPerceptionInfraredFrameSourceProperties(Local<Value> value);
  };

  Persistent<FunctionTemplate> KnownPerceptionInfraredFrameSourceProperties::s_constructorTemplate;

  v8::Local<v8::Value> WrapKnownPerceptionInfraredFrameSourceProperties(::Windows::Devices::Perception::KnownPerceptionInfraredFrameSourceProperties^ 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>(KnownPerceptionInfraredFrameSourceProperties::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::KnownPerceptionInfraredFrameSourceProperties^ UnwrapKnownPerceptionInfraredFrameSourceProperties(Local<Value> value) {
     return KnownPerceptionInfraredFrameSourceProperties::Unwrap<KnownPerceptionInfraredFrameSourceProperties>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitKnownPerceptionInfraredFrameSourceProperties(Local<Object> exports) {
    KnownPerceptionInfraredFrameSourceProperties::Init(exports);
  }

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






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

        Nan::SetAccessor(constructor, Nan::New<String>("maxDepth").ToLocalChecked(), MaxDepthGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("minDepth").ToLocalChecked(), MinDepthGetter);


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

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

    private:

      KnownPerceptionDepthFrameSourceProperties(::Windows::Devices::Perception::KnownPerceptionDepthFrameSourceProperties^ 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::Devices::Perception::KnownPerceptionDepthFrameSourceProperties^ winRtInstance;


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

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

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







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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownPerceptionDepthFrameSourceProperties::MaxDepth;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownPerceptionDepthFrameSourceProperties::MinDepth;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    private:
      ::Windows::Devices::Perception::KnownPerceptionDepthFrameSourceProperties^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapKnownPerceptionDepthFrameSourceProperties(::Windows::Devices::Perception::KnownPerceptionDepthFrameSourceProperties^ wintRtInstance);
      friend ::Windows::Devices::Perception::KnownPerceptionDepthFrameSourceProperties^ UnwrapKnownPerceptionDepthFrameSourceProperties(Local<Value> value);
  };

  Persistent<FunctionTemplate> KnownPerceptionDepthFrameSourceProperties::s_constructorTemplate;

  v8::Local<v8::Value> WrapKnownPerceptionDepthFrameSourceProperties(::Windows::Devices::Perception::KnownPerceptionDepthFrameSourceProperties^ 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>(KnownPerceptionDepthFrameSourceProperties::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::KnownPerceptionDepthFrameSourceProperties^ UnwrapKnownPerceptionDepthFrameSourceProperties(Local<Value> value) {
     return KnownPerceptionDepthFrameSourceProperties::Unwrap<KnownPerceptionDepthFrameSourceProperties>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitKnownPerceptionDepthFrameSourceProperties(Local<Object> exports) {
    KnownPerceptionDepthFrameSourceProperties::Init(exports);
  }

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






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

        Nan::SetAccessor(constructor, Nan::New<String>("autoExposureEnabled").ToLocalChecked(), AutoExposureEnabledGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("exposure").ToLocalChecked(), ExposureGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("exposureCompensation").ToLocalChecked(), ExposureCompensationGetter);


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

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

    private:

      KnownPerceptionColorFrameSourceProperties(::Windows::Devices::Perception::KnownPerceptionColorFrameSourceProperties^ 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::Devices::Perception::KnownPerceptionColorFrameSourceProperties^ winRtInstance;


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

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

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







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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownPerceptionColorFrameSourceProperties::AutoExposureEnabled;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownPerceptionColorFrameSourceProperties::Exposure;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownPerceptionColorFrameSourceProperties::ExposureCompensation;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    private:
      ::Windows::Devices::Perception::KnownPerceptionColorFrameSourceProperties^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapKnownPerceptionColorFrameSourceProperties(::Windows::Devices::Perception::KnownPerceptionColorFrameSourceProperties^ wintRtInstance);
      friend ::Windows::Devices::Perception::KnownPerceptionColorFrameSourceProperties^ UnwrapKnownPerceptionColorFrameSourceProperties(Local<Value> value);
  };

  Persistent<FunctionTemplate> KnownPerceptionColorFrameSourceProperties::s_constructorTemplate;

  v8::Local<v8::Value> WrapKnownPerceptionColorFrameSourceProperties(::Windows::Devices::Perception::KnownPerceptionColorFrameSourceProperties^ 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>(KnownPerceptionColorFrameSourceProperties::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::KnownPerceptionColorFrameSourceProperties^ UnwrapKnownPerceptionColorFrameSourceProperties(Local<Value> value) {
     return KnownPerceptionColorFrameSourceProperties::Unwrap<KnownPerceptionColorFrameSourceProperties>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitKnownPerceptionColorFrameSourceProperties(Local<Object> exports) {
    KnownPerceptionColorFrameSourceProperties::Init(exports);
  }

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






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

        Nan::SetAccessor(constructor, Nan::New<String>("bitmapAlphaMode").ToLocalChecked(), BitmapAlphaModeGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("bitmapPixelFormat").ToLocalChecked(), BitmapPixelFormatGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("frameDuration").ToLocalChecked(), FrameDurationGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("height").ToLocalChecked(), HeightGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("width").ToLocalChecked(), WidthGetter);


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

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

    private:

      KnownPerceptionVideoProfileProperties(::Windows::Devices::Perception::KnownPerceptionVideoProfileProperties^ 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::Devices::Perception::KnownPerceptionVideoProfileProperties^ winRtInstance;


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

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

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







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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownPerceptionVideoProfileProperties::BitmapAlphaMode;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownPerceptionVideoProfileProperties::BitmapPixelFormat;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownPerceptionVideoProfileProperties::FrameDuration;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownPerceptionVideoProfileProperties::Height;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownPerceptionVideoProfileProperties::Width;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    private:
      ::Windows::Devices::Perception::KnownPerceptionVideoProfileProperties^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapKnownPerceptionVideoProfileProperties(::Windows::Devices::Perception::KnownPerceptionVideoProfileProperties^ wintRtInstance);
      friend ::Windows::Devices::Perception::KnownPerceptionVideoProfileProperties^ UnwrapKnownPerceptionVideoProfileProperties(Local<Value> value);
  };

  Persistent<FunctionTemplate> KnownPerceptionVideoProfileProperties::s_constructorTemplate;

  v8::Local<v8::Value> WrapKnownPerceptionVideoProfileProperties(::Windows::Devices::Perception::KnownPerceptionVideoProfileProperties^ 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>(KnownPerceptionVideoProfileProperties::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::KnownPerceptionVideoProfileProperties^ UnwrapKnownPerceptionVideoProfileProperties(Local<Value> value) {
     return KnownPerceptionVideoProfileProperties::Unwrap<KnownPerceptionVideoProfileProperties>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitKnownPerceptionVideoProfileProperties(Local<Object> exports) {
    KnownPerceptionVideoProfileProperties::Init(exports);
  }

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






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

        Nan::SetAccessor(constructor, Nan::New<String>("focalLength").ToLocalChecked(), FocalLengthGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("principalPoint").ToLocalChecked(), PrincipalPointGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("radialDistortion").ToLocalChecked(), RadialDistortionGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("tangentialDistortion").ToLocalChecked(), TangentialDistortionGetter);


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

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

    private:

      KnownCameraIntrinsicsProperties(::Windows::Devices::Perception::KnownCameraIntrinsicsProperties^ 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::Devices::Perception::KnownCameraIntrinsicsProperties^ winRtInstance;


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

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

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







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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownCameraIntrinsicsProperties::FocalLength;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownCameraIntrinsicsProperties::PrincipalPoint;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownCameraIntrinsicsProperties::RadialDistortion;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Devices::Perception::KnownCameraIntrinsicsProperties::TangentialDistortion;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    private:
      ::Windows::Devices::Perception::KnownCameraIntrinsicsProperties^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapKnownCameraIntrinsicsProperties(::Windows::Devices::Perception::KnownCameraIntrinsicsProperties^ wintRtInstance);
      friend ::Windows::Devices::Perception::KnownCameraIntrinsicsProperties^ UnwrapKnownCameraIntrinsicsProperties(Local<Value> value);
  };

  Persistent<FunctionTemplate> KnownCameraIntrinsicsProperties::s_constructorTemplate;

  v8::Local<v8::Value> WrapKnownCameraIntrinsicsProperties(::Windows::Devices::Perception::KnownCameraIntrinsicsProperties^ 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>(KnownCameraIntrinsicsProperties::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Devices::Perception::KnownCameraIntrinsicsProperties^ UnwrapKnownCameraIntrinsicsProperties(Local<Value> value) {
     return KnownCameraIntrinsicsProperties::Unwrap<KnownCameraIntrinsicsProperties>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitKnownCameraIntrinsicsProperties(Local<Object> exports) {
    KnownCameraIntrinsicsProperties::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::Devices::Perception::InitPerceptionFrameSourceAccessStatusEnum(target);
      NodeRT::Windows::Devices::Perception::InitPerceptionFrameSourcePropertyChangeStatusEnum(target);
      NodeRT::Windows::Devices::Perception::InitPerceptionColorFrameSourceWatcher(target);
      NodeRT::Windows::Devices::Perception::InitPerceptionColorFrameSourceAddedEventArgs(target);
      NodeRT::Windows::Devices::Perception::InitPerceptionColorFrameSourceRemovedEventArgs(target);
      NodeRT::Windows::Devices::Perception::InitPerceptionDepthFrameSourceWatcher(target);
      NodeRT::Windows::Devices::Perception::InitPerceptionDepthFrameSourceAddedEventArgs(target);
      NodeRT::Windows::Devices::Perception::InitPerceptionDepthFrameSourceRemovedEventArgs(target);
      NodeRT::Windows::Devices::Perception::InitPerceptionInfraredFrameSourceWatcher(target);
      NodeRT::Windows::Devices::Perception::InitPerceptionInfraredFrameSourceAddedEventArgs(target);
      NodeRT::Windows::Devices::Perception::InitPerceptionInfraredFrameSourceRemovedEventArgs(target);
      NodeRT::Windows::Devices::Perception::InitPerceptionColorFrameSource(target);
      NodeRT::Windows::Devices::Perception::InitPerceptionDepthFrameSource(target);
      NodeRT::Windows::Devices::Perception::InitPerceptionInfraredFrameSource(target);
      NodeRT::Windows::Devices::Perception::InitPerceptionControlSession(target);
      NodeRT::Windows::Devices::Perception::InitPerceptionFrameSourcePropertyChangeResult(target);
      NodeRT::Windows::Devices::Perception::InitPerceptionFrameSourcePropertiesChangedEventArgs(target);
      NodeRT::Windows::Devices::Perception::InitPerceptionVideoProfile(target);
      NodeRT::Windows::Devices::Perception::InitPerceptionDepthCorrelatedCameraIntrinsics(target);
      NodeRT::Windows::Devices::Perception::InitPerceptionDepthCorrelatedCoordinateMapper(target);
      NodeRT::Windows::Devices::Perception::InitPerceptionColorFrameReader(target);
      NodeRT::Windows::Devices::Perception::InitPerceptionDepthFrameReader(target);
      NodeRT::Windows::Devices::Perception::InitPerceptionInfraredFrameReader(target);
      NodeRT::Windows::Devices::Perception::InitPerceptionColorFrameArrivedEventArgs(target);
      NodeRT::Windows::Devices::Perception::InitPerceptionColorFrame(target);
      NodeRT::Windows::Devices::Perception::InitPerceptionDepthFrameArrivedEventArgs(target);
      NodeRT::Windows::Devices::Perception::InitPerceptionDepthFrame(target);
      NodeRT::Windows::Devices::Perception::InitPerceptionInfraredFrameArrivedEventArgs(target);
      NodeRT::Windows::Devices::Perception::InitPerceptionInfraredFrame(target);
      NodeRT::Windows::Devices::Perception::InitKnownPerceptionFrameSourceProperties(target);
      NodeRT::Windows::Devices::Perception::InitKnownPerceptionVideoFrameSourceProperties(target);
      NodeRT::Windows::Devices::Perception::InitKnownPerceptionInfraredFrameSourceProperties(target);
      NodeRT::Windows::Devices::Perception::InitKnownPerceptionDepthFrameSourceProperties(target);
      NodeRT::Windows::Devices::Perception::InitKnownPerceptionColorFrameSourceProperties(target);
      NodeRT::Windows::Devices::Perception::InitKnownPerceptionVideoProfileProperties(target);
      NodeRT::Windows::Devices::Perception::InitKnownCameraIntrinsicsProperties(target);


  NodeRT::Utils::RegisterNameSpace("Windows.Devices.Perception", target);
}



NODE_MODULE(binding, init)