// 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 Media { namespace Miracast { 
  v8::Local<v8::Value> WrapMiracastReceiver(::Windows::Media::Miracast::MiracastReceiver^ wintRtInstance);
  ::Windows::Media::Miracast::MiracastReceiver^ UnwrapMiracastReceiver(Local<Value> value);
  
  v8::Local<v8::Value> WrapMiracastReceiverApplySettingsResult(::Windows::Media::Miracast::MiracastReceiverApplySettingsResult^ wintRtInstance);
  ::Windows::Media::Miracast::MiracastReceiverApplySettingsResult^ UnwrapMiracastReceiverApplySettingsResult(Local<Value> value);
  
  v8::Local<v8::Value> WrapMiracastReceiverConnection(::Windows::Media::Miracast::MiracastReceiverConnection^ wintRtInstance);
  ::Windows::Media::Miracast::MiracastReceiverConnection^ UnwrapMiracastReceiverConnection(Local<Value> value);
  
  v8::Local<v8::Value> WrapMiracastReceiverConnectionCreatedEventArgs(::Windows::Media::Miracast::MiracastReceiverConnectionCreatedEventArgs^ wintRtInstance);
  ::Windows::Media::Miracast::MiracastReceiverConnectionCreatedEventArgs^ UnwrapMiracastReceiverConnectionCreatedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapMiracastReceiverCursorImageChannel(::Windows::Media::Miracast::MiracastReceiverCursorImageChannel^ wintRtInstance);
  ::Windows::Media::Miracast::MiracastReceiverCursorImageChannel^ UnwrapMiracastReceiverCursorImageChannel(Local<Value> value);
  
  v8::Local<v8::Value> WrapMiracastReceiverCursorImageChannelSettings(::Windows::Media::Miracast::MiracastReceiverCursorImageChannelSettings^ wintRtInstance);
  ::Windows::Media::Miracast::MiracastReceiverCursorImageChannelSettings^ UnwrapMiracastReceiverCursorImageChannelSettings(Local<Value> value);
  
  v8::Local<v8::Value> WrapMiracastReceiverDisconnectedEventArgs(::Windows::Media::Miracast::MiracastReceiverDisconnectedEventArgs^ wintRtInstance);
  ::Windows::Media::Miracast::MiracastReceiverDisconnectedEventArgs^ UnwrapMiracastReceiverDisconnectedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapMiracastReceiverGameControllerDevice(::Windows::Media::Miracast::MiracastReceiverGameControllerDevice^ wintRtInstance);
  ::Windows::Media::Miracast::MiracastReceiverGameControllerDevice^ UnwrapMiracastReceiverGameControllerDevice(Local<Value> value);
  
  v8::Local<v8::Value> WrapMiracastReceiverInputDevices(::Windows::Media::Miracast::MiracastReceiverInputDevices^ wintRtInstance);
  ::Windows::Media::Miracast::MiracastReceiverInputDevices^ UnwrapMiracastReceiverInputDevices(Local<Value> value);
  
  v8::Local<v8::Value> WrapMiracastReceiverKeyboardDevice(::Windows::Media::Miracast::MiracastReceiverKeyboardDevice^ wintRtInstance);
  ::Windows::Media::Miracast::MiracastReceiverKeyboardDevice^ UnwrapMiracastReceiverKeyboardDevice(Local<Value> value);
  
  v8::Local<v8::Value> WrapMiracastReceiverMediaSourceCreatedEventArgs(::Windows::Media::Miracast::MiracastReceiverMediaSourceCreatedEventArgs^ wintRtInstance);
  ::Windows::Media::Miracast::MiracastReceiverMediaSourceCreatedEventArgs^ UnwrapMiracastReceiverMediaSourceCreatedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapMiracastReceiverSession(::Windows::Media::Miracast::MiracastReceiverSession^ wintRtInstance);
  ::Windows::Media::Miracast::MiracastReceiverSession^ UnwrapMiracastReceiverSession(Local<Value> value);
  
  v8::Local<v8::Value> WrapMiracastReceiverSessionStartResult(::Windows::Media::Miracast::MiracastReceiverSessionStartResult^ wintRtInstance);
  ::Windows::Media::Miracast::MiracastReceiverSessionStartResult^ UnwrapMiracastReceiverSessionStartResult(Local<Value> value);
  
  v8::Local<v8::Value> WrapMiracastReceiverSettings(::Windows::Media::Miracast::MiracastReceiverSettings^ wintRtInstance);
  ::Windows::Media::Miracast::MiracastReceiverSettings^ UnwrapMiracastReceiverSettings(Local<Value> value);
  
  v8::Local<v8::Value> WrapMiracastReceiverStatus(::Windows::Media::Miracast::MiracastReceiverStatus^ wintRtInstance);
  ::Windows::Media::Miracast::MiracastReceiverStatus^ UnwrapMiracastReceiverStatus(Local<Value> value);
  
  v8::Local<v8::Value> WrapMiracastReceiverStreamControl(::Windows::Media::Miracast::MiracastReceiverStreamControl^ wintRtInstance);
  ::Windows::Media::Miracast::MiracastReceiverStreamControl^ UnwrapMiracastReceiverStreamControl(Local<Value> value);
  
  v8::Local<v8::Value> WrapMiracastReceiverVideoStreamSettings(::Windows::Media::Miracast::MiracastReceiverVideoStreamSettings^ wintRtInstance);
  ::Windows::Media::Miracast::MiracastReceiverVideoStreamSettings^ UnwrapMiracastReceiverVideoStreamSettings(Local<Value> value);
  
  v8::Local<v8::Value> WrapMiracastTransmitter(::Windows::Media::Miracast::MiracastTransmitter^ wintRtInstance);
  ::Windows::Media::Miracast::MiracastTransmitter^ UnwrapMiracastTransmitter(Local<Value> value);
  



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

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

    Nan::Set(exports, Nan::New<String>("MiracastReceiverApplySettingsStatus").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("success").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverApplySettingsStatus::Success)));
    Nan::Set(enumObject, Nan::New<String>("unknownFailure").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverApplySettingsStatus::UnknownFailure)));
    Nan::Set(enumObject, Nan::New<String>("miracastNotSupported").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverApplySettingsStatus::MiracastNotSupported)));
    Nan::Set(enumObject, Nan::New<String>("accessDenied").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverApplySettingsStatus::AccessDenied)));
    Nan::Set(enumObject, Nan::New<String>("friendlyNameTooLong").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverApplySettingsStatus::FriendlyNameTooLong)));
    Nan::Set(enumObject, Nan::New<String>("modelNameTooLong").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverApplySettingsStatus::ModelNameTooLong)));
    Nan::Set(enumObject, Nan::New<String>("modelNumberTooLong").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverApplySettingsStatus::ModelNumberTooLong)));
    Nan::Set(enumObject, Nan::New<String>("invalidSettings").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverApplySettingsStatus::InvalidSettings)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("MiracastReceiverAuthorizationMethod").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverAuthorizationMethod::None)));
    Nan::Set(enumObject, Nan::New<String>("confirmConnection").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverAuthorizationMethod::ConfirmConnection)));
    Nan::Set(enumObject, Nan::New<String>("pinDisplayIfRequested").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverAuthorizationMethod::PinDisplayIfRequested)));
    Nan::Set(enumObject, Nan::New<String>("pinDisplayRequired").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverAuthorizationMethod::PinDisplayRequired)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("MiracastReceiverDisconnectReason").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("finished").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverDisconnectReason::Finished)));
    Nan::Set(enumObject, Nan::New<String>("appSpecificError").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverDisconnectReason::AppSpecificError)));
    Nan::Set(enumObject, Nan::New<String>("connectionNotAccepted").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverDisconnectReason::ConnectionNotAccepted)));
    Nan::Set(enumObject, Nan::New<String>("disconnectedByUser").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverDisconnectReason::DisconnectedByUser)));
    Nan::Set(enumObject, Nan::New<String>("failedToStartStreaming").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverDisconnectReason::FailedToStartStreaming)));
    Nan::Set(enumObject, Nan::New<String>("mediaDecodingError").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverDisconnectReason::MediaDecodingError)));
    Nan::Set(enumObject, Nan::New<String>("mediaStreamingError").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverDisconnectReason::MediaStreamingError)));
    Nan::Set(enumObject, Nan::New<String>("mediaDecryptionError").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverDisconnectReason::MediaDecryptionError)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("MiracastReceiverGameControllerDeviceUsageMode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("asGameController").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverGameControllerDeviceUsageMode::AsGameController)));
    Nan::Set(enumObject, Nan::New<String>("asMouseAndKeyboard").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverGameControllerDeviceUsageMode::AsMouseAndKeyboard)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("MiracastReceiverListeningStatus").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("notListening").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverListeningStatus::NotListening)));
    Nan::Set(enumObject, Nan::New<String>("listening").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverListeningStatus::Listening)));
    Nan::Set(enumObject, Nan::New<String>("connectionPending").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverListeningStatus::ConnectionPending)));
    Nan::Set(enumObject, Nan::New<String>("connected").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverListeningStatus::Connected)));
    Nan::Set(enumObject, Nan::New<String>("disabledByPolicy").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverListeningStatus::DisabledByPolicy)));
    Nan::Set(enumObject, Nan::New<String>("temporarilyDisabled").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverListeningStatus::TemporarilyDisabled)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("MiracastReceiverSessionStartStatus").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("success").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverSessionStartStatus::Success)));
    Nan::Set(enumObject, Nan::New<String>("unknownFailure").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverSessionStartStatus::UnknownFailure)));
    Nan::Set(enumObject, Nan::New<String>("miracastNotSupported").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverSessionStartStatus::MiracastNotSupported)));
    Nan::Set(enumObject, Nan::New<String>("accessDenied").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverSessionStartStatus::AccessDenied)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("MiracastReceiverWiFiStatus").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("miracastSupportUndetermined").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverWiFiStatus::MiracastSupportUndetermined)));
    Nan::Set(enumObject, Nan::New<String>("miracastNotSupported").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverWiFiStatus::MiracastNotSupported)));
    Nan::Set(enumObject, Nan::New<String>("miracastSupportNotOptimized").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverWiFiStatus::MiracastSupportNotOptimized)));
    Nan::Set(enumObject, Nan::New<String>("miracastSupported").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastReceiverWiFiStatus::MiracastSupported)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("MiracastTransmitterAuthorizationStatus").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("undecided").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastTransmitterAuthorizationStatus::Undecided)));
    Nan::Set(enumObject, Nan::New<String>("allowed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastTransmitterAuthorizationStatus::Allowed)));
    Nan::Set(enumObject, Nan::New<String>("alwaysPrompt").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastTransmitterAuthorizationStatus::AlwaysPrompt)));
    Nan::Set(enumObject, Nan::New<String>("blocked").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Miracast::MiracastTransmitterAuthorizationStatus::Blocked)));
  }


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

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

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

  ::Windows::Graphics::SizeInt32 SizeInt32FromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::Graphics::SizeInt32 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>("width").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.Width = static_cast<int>(Nan::To<int32_t>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0));
    }
    
    symbol = Nan::New<String>("height").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.Height = static_cast<int>(Nan::To<int32_t>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0));
    }
    
    return returnValue;
  }

  Local<Value> SizeInt32ToJsObject(::Windows::Graphics::SizeInt32 value) {
    EscapableHandleScope scope;

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

    Nan::Set(obj, Nan::New<String>("width").ToLocalChecked(), Nan::New<Integer>(value.Width));
    Nan::Set(obj, Nan::New<String>("height").ToLocalChecked(), Nan::New<Integer>(value.Height));

    return scope.Escape(obj);
  }
  static bool IsPointInt32JsObject(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()->IsInt32()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("y").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsInt32()) {
        return false;
      }
    }
    
    return true;
  }

  ::Windows::Graphics::PointInt32 PointInt32FromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::Graphics::PointInt32 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<int>(Nan::To<int32_t>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0));
    }
    
    symbol = Nan::New<String>("y").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.Y = static_cast<int>(Nan::To<int32_t>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0));
    }
    
    return returnValue;
  }

  Local<Value> PointInt32ToJsObject(::Windows::Graphics::PointInt32 value) {
    EscapableHandleScope scope;

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

    Nan::Set(obj, Nan::New<String>("x").ToLocalChecked(), Nan::New<Integer>(value.X));
    Nan::Set(obj, Nan::New<String>("y").ToLocalChecked(), Nan::New<Integer>(value.Y));

    return scope.Escape(obj);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "getDefaultSettings", GetDefaultSettings);
            Nan::SetPrototypeMethod(localRef, "getCurrentSettings", GetCurrentSettings);
            Nan::SetPrototypeMethod(localRef, "disconnectAllAndApplySettings", DisconnectAllAndApplySettings);
            Nan::SetPrototypeMethod(localRef, "getStatus", GetStatus);
            Nan::SetPrototypeMethod(localRef, "createSession", CreateSession);
            Nan::SetPrototypeMethod(localRef, "clearKnownTransmitters", ClearKnownTransmitters);
            Nan::SetPrototypeMethod(localRef, "removeKnownTransmitter", RemoveKnownTransmitter);
          

          
            Nan::SetPrototypeMethod(localRef, "getCurrentSettingsAsync", GetCurrentSettingsAsync);
            Nan::SetPrototypeMethod(localRef, "disconnectAllAndApplySettingsAsync", DisconnectAllAndApplySettingsAsync);
            Nan::SetPrototypeMethod(localRef, "getStatusAsync", GetStatusAsync);
            Nan::SetPrototypeMethod(localRef, "createSessionAsync", CreateSessionAsync);
          

          
          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>("MiracastReceiver").ToLocalChecked(), constructor);
      }

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

    private:

      MiracastReceiver(::Windows::Media::Miracast::MiracastReceiver^ 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::Media::Miracast::MiracastReceiver^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiver^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Media::Miracast::MiracastReceiverSettings^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->GetCurrentSettingsAsync();
        }
        catch (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::Media::Miracast::MiracastReceiverSettings^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiver^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Media::Miracast::MiracastReceiverApplySettingsResult^>^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverSettings^>(info[0]))
      {
        try
        {
          ::Windows::Media::Miracast::MiracastReceiverSettings^ arg0 = UnwrapMiracastReceiverSettings(info[0]);
          
          op = wrapper->_instance->DisconnectAllAndApplySettingsAsync(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::Media::Miracast::MiracastReceiverApplySettingsResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiver^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Media::Miracast::MiracastReceiverStatus^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->GetStatusAsync();
        }
        catch (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::Media::Miracast::MiracastReceiverStatus^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiver^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Media::Miracast::MiracastReceiverSession^>^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Core::CoreApplicationView^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Core::CoreApplicationView^ arg0 = dynamic_cast<::Windows::ApplicationModel::Core::CoreApplicationView^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          op = wrapper->_instance->CreateSessionAsync(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::Media::Miracast::MiracastReceiverSession^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiver^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Media::Miracast::MiracastReceiverSettings^ result;
          result = wrapper->_instance->GetDefaultSettings();
          info.GetReturnValue().Set(WrapMiracastReceiverSettings(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 GetCurrentSettings(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiver^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Media::Miracast::MiracastReceiverSettings^ result;
          result = wrapper->_instance->GetCurrentSettings();
          info.GetReturnValue().Set(WrapMiracastReceiverSettings(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 DisconnectAllAndApplySettings(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiver^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverSettings^>(info[0]))
      {
        try
        {
          ::Windows::Media::Miracast::MiracastReceiverSettings^ arg0 = UnwrapMiracastReceiverSettings(info[0]);
          
          ::Windows::Media::Miracast::MiracastReceiverApplySettingsResult^ result;
          result = wrapper->_instance->DisconnectAllAndApplySettings(arg0);
          info.GetReturnValue().Set(WrapMiracastReceiverApplySettingsResult(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 GetStatus(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiver^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Media::Miracast::MiracastReceiverStatus^ result;
          result = wrapper->_instance->GetStatus();
          info.GetReturnValue().Set(WrapMiracastReceiverStatus(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 CreateSession(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiver^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Core::CoreApplicationView^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Core::CoreApplicationView^ arg0 = dynamic_cast<::Windows::ApplicationModel::Core::CoreApplicationView^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::Media::Miracast::MiracastReceiverSession^ result;
          result = wrapper->_instance->CreateSession(arg0);
          info.GetReturnValue().Set(WrapMiracastReceiverSession(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 ClearKnownTransmitters(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiver^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiver^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastTransmitter^>(info[0]))
      {
        try
        {
          ::Windows::Media::Miracast::MiracastTransmitter^ arg0 = UnwrapMiracastTransmitter(info[0]);
          
          wrapper->_instance->RemoveKnownTransmitter(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





    static void 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"statusChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiver^>(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;
        }
        MiracastReceiver *wrapper = MiracastReceiver::Unwrap<MiracastReceiver>(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->StatusChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Miracast::MiracastReceiver^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Media::Miracast::MiracastReceiver^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapMiracastReceiver(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"statusChanged", 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"statusChanged", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiver^>(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;
          }
          MiracastReceiver *wrapper = MiracastReceiver::Unwrap<MiracastReceiver>(info.This());
          wrapper->_instance->StatusChanged::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::Media::Miracast::MiracastReceiver^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMiracastReceiver(::Windows::Media::Miracast::MiracastReceiver^ wintRtInstance);
      friend ::Windows::Media::Miracast::MiracastReceiver^ UnwrapMiracastReceiver(Local<Value> value);
  };

  Persistent<FunctionTemplate> MiracastReceiver::s_constructorTemplate;

  v8::Local<v8::Value> WrapMiracastReceiver(::Windows::Media::Miracast::MiracastReceiver^ 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>(MiracastReceiver::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Miracast::MiracastReceiver^ UnwrapMiracastReceiver(Local<Value> value) {
     return MiracastReceiver::Unwrap<MiracastReceiver>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMiracastReceiver(Local<Object> exports) {
    MiracastReceiver::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("extendedError").ToLocalChecked(), ExtendedErrorGetter);
            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>("MiracastReceiverApplySettingsResult").ToLocalChecked(), constructor);
      }

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

    private:

      MiracastReceiverApplySettingsResult(::Windows::Media::Miracast::MiracastReceiverApplySettingsResult^ 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::Media::Miracast::MiracastReceiverApplySettingsResult^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverApplySettingsResult^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::HResult result = wrapper->_instance->ExtendedError;
        info.GetReturnValue().Set(Nan::New<Integer>(result.Value));
        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::Media::Miracast::MiracastReceiverApplySettingsResult^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Media::Miracast::MiracastReceiverApplySettingsStatus 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::Media::Miracast::MiracastReceiverApplySettingsResult^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMiracastReceiverApplySettingsResult(::Windows::Media::Miracast::MiracastReceiverApplySettingsResult^ wintRtInstance);
      friend ::Windows::Media::Miracast::MiracastReceiverApplySettingsResult^ UnwrapMiracastReceiverApplySettingsResult(Local<Value> value);
  };

  Persistent<FunctionTemplate> MiracastReceiverApplySettingsResult::s_constructorTemplate;

  v8::Local<v8::Value> WrapMiracastReceiverApplySettingsResult(::Windows::Media::Miracast::MiracastReceiverApplySettingsResult^ 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>(MiracastReceiverApplySettingsResult::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Miracast::MiracastReceiverApplySettingsResult^ UnwrapMiracastReceiverApplySettingsResult(Local<Value> value) {
     return MiracastReceiverApplySettingsResult::Unwrap<MiracastReceiverApplySettingsResult>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMiracastReceiverApplySettingsResult(Local<Object> exports) {
    MiracastReceiverApplySettingsResult::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "disconnect", Disconnect);
            Nan::SetPrototypeMethod(localRef, "pause", Pause);
            Nan::SetPrototypeMethod(localRef, "resume", Resume);
            Nan::SetPrototypeMethod(localRef, "close", Close);
          

          
            Nan::SetPrototypeMethod(localRef, "pauseAsync", PauseAsync);
            Nan::SetPrototypeMethod(localRef, "resumeAsync", ResumeAsync);
          


          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("cursorImageChannel").ToLocalChecked(), CursorImageChannelGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("inputDevices").ToLocalChecked(), InputDevicesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("streamControl").ToLocalChecked(), StreamControlGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("transmitter").ToLocalChecked(), TransmitterGetter);

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



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

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

    private:

      MiracastReceiverConnection(::Windows::Media::Miracast::MiracastReceiverConnection^ 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::Media::Miracast::MiracastReceiverConnection^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverConnection^>(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;
      }

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

      ::Windows::Foundation::IAsyncAction^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->PauseAsync();
        }
        catch (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 ResumeAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverConnection^>(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;
      }

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

      ::Windows::Foundation::IAsyncAction^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->ResumeAsync();
        }
        catch (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 Disconnect(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverConnection^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::Media::Miracast::MiracastReceiverDisconnectReason arg0 = static_cast<::Windows::Media::Miracast::MiracastReceiverDisconnectReason>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          wrapper->_instance->Disconnect(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && info[0]->IsInt32()
        && info[1]->IsString())
      {
        try
        {
          ::Windows::Media::Miracast::MiracastReceiverDisconnectReason arg0 = static_cast<::Windows::Media::Miracast::MiracastReceiverDisconnectReason>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          
          wrapper->_instance->Disconnect(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Pause(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverConnection^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverConnection^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->Resume();
          return;
        } catch (Platform::Exception ^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::Media::Miracast::MiracastReceiverConnection^>(info.This())) {
        return;
      }

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverConnection^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverConnection^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverConnection^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverConnection^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Media::Miracast::MiracastTransmitter^ result = wrapper->_instance->Transmitter;
        info.GetReturnValue().Set(WrapMiracastTransmitter(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Miracast::MiracastReceiverConnection^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMiracastReceiverConnection(::Windows::Media::Miracast::MiracastReceiverConnection^ wintRtInstance);
      friend ::Windows::Media::Miracast::MiracastReceiverConnection^ UnwrapMiracastReceiverConnection(Local<Value> value);
  };

  Persistent<FunctionTemplate> MiracastReceiverConnection::s_constructorTemplate;

  v8::Local<v8::Value> WrapMiracastReceiverConnection(::Windows::Media::Miracast::MiracastReceiverConnection^ 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>(MiracastReceiverConnection::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Miracast::MiracastReceiverConnection^ UnwrapMiracastReceiverConnection(Local<Value> value) {
     return MiracastReceiverConnection::Unwrap<MiracastReceiverConnection>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMiracastReceiverConnection(Local<Object> exports) {
    MiracastReceiverConnection::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getDeferral", GetDeferral);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("connection").ToLocalChecked(), ConnectionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pin").ToLocalChecked(), PinGetter);

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



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

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

    private:

      MiracastReceiverConnectionCreatedEventArgs(::Windows::Media::Miracast::MiracastReceiverConnectionCreatedEventArgs^ 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::Media::Miracast::MiracastReceiverConnectionCreatedEventArgs^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverConnectionCreatedEventArgs^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Deferral^ result;
          result = wrapper->_instance->GetDeferral();
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "Deferral", 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 ConnectionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverConnectionCreatedEventArgs^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverConnectionCreatedEventArgs^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Media::Miracast::MiracastReceiverConnectionCreatedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMiracastReceiverConnectionCreatedEventArgs(::Windows::Media::Miracast::MiracastReceiverConnectionCreatedEventArgs^ wintRtInstance);
      friend ::Windows::Media::Miracast::MiracastReceiverConnectionCreatedEventArgs^ UnwrapMiracastReceiverConnectionCreatedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> MiracastReceiverConnectionCreatedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapMiracastReceiverConnectionCreatedEventArgs(::Windows::Media::Miracast::MiracastReceiverConnectionCreatedEventArgs^ 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>(MiracastReceiverConnectionCreatedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Miracast::MiracastReceiverConnectionCreatedEventArgs^ UnwrapMiracastReceiverConnectionCreatedEventArgs(Local<Value> value) {
     return MiracastReceiverConnectionCreatedEventArgs::Unwrap<MiracastReceiverConnectionCreatedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMiracastReceiverConnectionCreatedEventArgs(Local<Object> exports) {
    MiracastReceiverConnectionCreatedEventArgs::Init(exports);
  }

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




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

          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("imageStream").ToLocalChecked(), ImageStreamGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isEnabled").ToLocalChecked(), IsEnabledGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxImageSize").ToLocalChecked(), MaxImageSizeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("position").ToLocalChecked(), PositionGetter);

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



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

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

    private:

      MiracastReceiverCursorImageChannel(::Windows::Media::Miracast::MiracastReceiverCursorImageChannel^ 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::Media::Miracast::MiracastReceiverCursorImageChannel^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverCursorImageChannel^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverCursorImageChannel^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverCursorImageChannel^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverCursorImageChannel^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Graphics::PointInt32 result = wrapper->_instance->Position;
        info.GetReturnValue().Set(PointInt32ToJsObject(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"imageStreamChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverCursorImageChannel^>(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;
        }
        MiracastReceiverCursorImageChannel *wrapper = MiracastReceiverCursorImageChannel::Unwrap<MiracastReceiverCursorImageChannel>(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->ImageStreamChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Miracast::MiracastReceiverCursorImageChannel^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Media::Miracast::MiracastReceiverCursorImageChannel^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapMiracastReceiverCursorImageChannel(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"positionChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverCursorImageChannel^>(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;
        }
        MiracastReceiverCursorImageChannel *wrapper = MiracastReceiverCursorImageChannel::Unwrap<MiracastReceiverCursorImageChannel>(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->PositionChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Miracast::MiracastReceiverCursorImageChannel^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Media::Miracast::MiracastReceiverCursorImageChannel^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapMiracastReceiverCursorImageChannel(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"imageStreamChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"positionChanged", 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"imageStreamChanged", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverCursorImageChannel^>(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;
          }
          MiracastReceiverCursorImageChannel *wrapper = MiracastReceiverCursorImageChannel::Unwrap<MiracastReceiverCursorImageChannel>(info.This());
          wrapper->_instance->ImageStreamChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"positionChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverCursorImageChannel^>(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;
          }
          MiracastReceiverCursorImageChannel *wrapper = MiracastReceiverCursorImageChannel::Unwrap<MiracastReceiverCursorImageChannel>(info.This());
          wrapper->_instance->PositionChanged::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::Media::Miracast::MiracastReceiverCursorImageChannel^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMiracastReceiverCursorImageChannel(::Windows::Media::Miracast::MiracastReceiverCursorImageChannel^ wintRtInstance);
      friend ::Windows::Media::Miracast::MiracastReceiverCursorImageChannel^ UnwrapMiracastReceiverCursorImageChannel(Local<Value> value);
  };

  Persistent<FunctionTemplate> MiracastReceiverCursorImageChannel::s_constructorTemplate;

  v8::Local<v8::Value> WrapMiracastReceiverCursorImageChannel(::Windows::Media::Miracast::MiracastReceiverCursorImageChannel^ 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>(MiracastReceiverCursorImageChannel::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Miracast::MiracastReceiverCursorImageChannel^ UnwrapMiracastReceiverCursorImageChannel(Local<Value> value) {
     return MiracastReceiverCursorImageChannel::Unwrap<MiracastReceiverCursorImageChannel>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMiracastReceiverCursorImageChannel(Local<Object> exports) {
    MiracastReceiverCursorImageChannel::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxImageSize").ToLocalChecked(), MaxImageSizeGetter, MaxImageSizeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isEnabled").ToLocalChecked(), IsEnabledGetter, IsEnabledSetter);

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



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

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

    private:

      MiracastReceiverCursorImageChannelSettings(::Windows::Media::Miracast::MiracastReceiverCursorImageChannelSettings^ 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::Media::Miracast::MiracastReceiverCursorImageChannelSettings^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverCursorImageChannelSettings^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverCursorImageChannelSettings^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Graphics::SizeInt32 winRtValue = SizeInt32FromJsObject(value);

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverCursorImageChannelSettings^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->IsEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsEnabledSetter(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::Media::Miracast::MiracastReceiverCursorImageChannelSettings^>(info.This())) {
        return;
      }

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

      try {

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

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


    private:
      ::Windows::Media::Miracast::MiracastReceiverCursorImageChannelSettings^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMiracastReceiverCursorImageChannelSettings(::Windows::Media::Miracast::MiracastReceiverCursorImageChannelSettings^ wintRtInstance);
      friend ::Windows::Media::Miracast::MiracastReceiverCursorImageChannelSettings^ UnwrapMiracastReceiverCursorImageChannelSettings(Local<Value> value);
  };

  Persistent<FunctionTemplate> MiracastReceiverCursorImageChannelSettings::s_constructorTemplate;

  v8::Local<v8::Value> WrapMiracastReceiverCursorImageChannelSettings(::Windows::Media::Miracast::MiracastReceiverCursorImageChannelSettings^ 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>(MiracastReceiverCursorImageChannelSettings::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Miracast::MiracastReceiverCursorImageChannelSettings^ UnwrapMiracastReceiverCursorImageChannelSettings(Local<Value> value) {
     return MiracastReceiverCursorImageChannelSettings::Unwrap<MiracastReceiverCursorImageChannelSettings>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMiracastReceiverCursorImageChannelSettings(Local<Object> exports) {
    MiracastReceiverCursorImageChannelSettings::Init(exports);
  }

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





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

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



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

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

    private:

      MiracastReceiverDisconnectedEventArgs(::Windows::Media::Miracast::MiracastReceiverDisconnectedEventArgs^ 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::Media::Miracast::MiracastReceiverDisconnectedEventArgs^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverDisconnectedEventArgs^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Media::Miracast::MiracastReceiverConnection^ result = wrapper->_instance->Connection;
        info.GetReturnValue().Set(WrapMiracastReceiverConnection(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Miracast::MiracastReceiverDisconnectedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMiracastReceiverDisconnectedEventArgs(::Windows::Media::Miracast::MiracastReceiverDisconnectedEventArgs^ wintRtInstance);
      friend ::Windows::Media::Miracast::MiracastReceiverDisconnectedEventArgs^ UnwrapMiracastReceiverDisconnectedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> MiracastReceiverDisconnectedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapMiracastReceiverDisconnectedEventArgs(::Windows::Media::Miracast::MiracastReceiverDisconnectedEventArgs^ 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>(MiracastReceiverDisconnectedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Miracast::MiracastReceiverDisconnectedEventArgs^ UnwrapMiracastReceiverDisconnectedEventArgs(Local<Value> value) {
     return MiracastReceiverDisconnectedEventArgs::Unwrap<MiracastReceiverDisconnectedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMiracastReceiverDisconnectedEventArgs(Local<Object> exports) {
    MiracastReceiverDisconnectedEventArgs::Init(exports);
  }

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




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

          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("transmitInput").ToLocalChecked(), TransmitInputGetter, TransmitInputSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("mode").ToLocalChecked(), ModeGetter, ModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isRequestedByTransmitter").ToLocalChecked(), IsRequestedByTransmitterGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isTransmittingInput").ToLocalChecked(), IsTransmittingInputGetter);

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



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

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

    private:

      MiracastReceiverGameControllerDevice(::Windows::Media::Miracast::MiracastReceiverGameControllerDevice^ 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::Media::Miracast::MiracastReceiverGameControllerDevice^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverGameControllerDevice^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->TransmitInput;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TransmitInputSetter(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::Media::Miracast::MiracastReceiverGameControllerDevice^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverGameControllerDevice^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverGameControllerDevice^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Media::Miracast::MiracastReceiverGameControllerDeviceUsageMode winRtValue = static_cast<::Windows::Media::Miracast::MiracastReceiverGameControllerDeviceUsageMode>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverGameControllerDevice^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverGameControllerDevice^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->IsTransmittingInput;
        info.GetReturnValue().Set(Nan::New<Boolean>(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"changed", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverGameControllerDevice^>(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;
        }
        MiracastReceiverGameControllerDevice *wrapper = MiracastReceiverGameControllerDevice::Unwrap<MiracastReceiverGameControllerDevice>(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->Changed::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Miracast::MiracastReceiverGameControllerDevice^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Media::Miracast::MiracastReceiverGameControllerDevice^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapMiracastReceiverGameControllerDevice(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"changed", 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"changed", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverGameControllerDevice^>(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;
          }
          MiracastReceiverGameControllerDevice *wrapper = MiracastReceiverGameControllerDevice::Unwrap<MiracastReceiverGameControllerDevice>(info.This());
          wrapper->_instance->Changed::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::Media::Miracast::MiracastReceiverGameControllerDevice^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMiracastReceiverGameControllerDevice(::Windows::Media::Miracast::MiracastReceiverGameControllerDevice^ wintRtInstance);
      friend ::Windows::Media::Miracast::MiracastReceiverGameControllerDevice^ UnwrapMiracastReceiverGameControllerDevice(Local<Value> value);
  };

  Persistent<FunctionTemplate> MiracastReceiverGameControllerDevice::s_constructorTemplate;

  v8::Local<v8::Value> WrapMiracastReceiverGameControllerDevice(::Windows::Media::Miracast::MiracastReceiverGameControllerDevice^ 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>(MiracastReceiverGameControllerDevice::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Miracast::MiracastReceiverGameControllerDevice^ UnwrapMiracastReceiverGameControllerDevice(Local<Value> value) {
     return MiracastReceiverGameControllerDevice::Unwrap<MiracastReceiverGameControllerDevice>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMiracastReceiverGameControllerDevice(Local<Object> exports) {
    MiracastReceiverGameControllerDevice::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("gameController").ToLocalChecked(), GameControllerGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("keyboard").ToLocalChecked(), KeyboardGetter);

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



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

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

    private:

      MiracastReceiverInputDevices(::Windows::Media::Miracast::MiracastReceiverInputDevices^ 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::Media::Miracast::MiracastReceiverInputDevices^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverInputDevices^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverInputDevices^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Media::Miracast::MiracastReceiverKeyboardDevice^ result = wrapper->_instance->Keyboard;
        info.GetReturnValue().Set(WrapMiracastReceiverKeyboardDevice(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Miracast::MiracastReceiverInputDevices^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMiracastReceiverInputDevices(::Windows::Media::Miracast::MiracastReceiverInputDevices^ wintRtInstance);
      friend ::Windows::Media::Miracast::MiracastReceiverInputDevices^ UnwrapMiracastReceiverInputDevices(Local<Value> value);
  };

  Persistent<FunctionTemplate> MiracastReceiverInputDevices::s_constructorTemplate;

  v8::Local<v8::Value> WrapMiracastReceiverInputDevices(::Windows::Media::Miracast::MiracastReceiverInputDevices^ 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>(MiracastReceiverInputDevices::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Miracast::MiracastReceiverInputDevices^ UnwrapMiracastReceiverInputDevices(Local<Value> value) {
     return MiracastReceiverInputDevices::Unwrap<MiracastReceiverInputDevices>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMiracastReceiverInputDevices(Local<Object> exports) {
    MiracastReceiverInputDevices::Init(exports);
  }

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




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

          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("transmitInput").ToLocalChecked(), TransmitInputGetter, TransmitInputSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isRequestedByTransmitter").ToLocalChecked(), IsRequestedByTransmitterGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isTransmittingInput").ToLocalChecked(), IsTransmittingInputGetter);

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



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

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

    private:

      MiracastReceiverKeyboardDevice(::Windows::Media::Miracast::MiracastReceiverKeyboardDevice^ 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::Media::Miracast::MiracastReceiverKeyboardDevice^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverKeyboardDevice^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->TransmitInput;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TransmitInputSetter(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::Media::Miracast::MiracastReceiverKeyboardDevice^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverKeyboardDevice^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverKeyboardDevice^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->IsTransmittingInput;
        info.GetReturnValue().Set(Nan::New<Boolean>(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"changed", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverKeyboardDevice^>(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;
        }
        MiracastReceiverKeyboardDevice *wrapper = MiracastReceiverKeyboardDevice::Unwrap<MiracastReceiverKeyboardDevice>(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->Changed::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Miracast::MiracastReceiverKeyboardDevice^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Media::Miracast::MiracastReceiverKeyboardDevice^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapMiracastReceiverKeyboardDevice(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"changed", 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"changed", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverKeyboardDevice^>(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;
          }
          MiracastReceiverKeyboardDevice *wrapper = MiracastReceiverKeyboardDevice::Unwrap<MiracastReceiverKeyboardDevice>(info.This());
          wrapper->_instance->Changed::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::Media::Miracast::MiracastReceiverKeyboardDevice^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMiracastReceiverKeyboardDevice(::Windows::Media::Miracast::MiracastReceiverKeyboardDevice^ wintRtInstance);
      friend ::Windows::Media::Miracast::MiracastReceiverKeyboardDevice^ UnwrapMiracastReceiverKeyboardDevice(Local<Value> value);
  };

  Persistent<FunctionTemplate> MiracastReceiverKeyboardDevice::s_constructorTemplate;

  v8::Local<v8::Value> WrapMiracastReceiverKeyboardDevice(::Windows::Media::Miracast::MiracastReceiverKeyboardDevice^ 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>(MiracastReceiverKeyboardDevice::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Miracast::MiracastReceiverKeyboardDevice^ UnwrapMiracastReceiverKeyboardDevice(Local<Value> value) {
     return MiracastReceiverKeyboardDevice::Unwrap<MiracastReceiverKeyboardDevice>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMiracastReceiverKeyboardDevice(Local<Object> exports) {
    MiracastReceiverKeyboardDevice::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getDeferral", GetDeferral);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("connection").ToLocalChecked(), ConnectionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("cursorImageChannelSettings").ToLocalChecked(), CursorImageChannelSettingsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("mediaSource").ToLocalChecked(), MediaSourceGetter);

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



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

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

    private:

      MiracastReceiverMediaSourceCreatedEventArgs(::Windows::Media::Miracast::MiracastReceiverMediaSourceCreatedEventArgs^ 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::Media::Miracast::MiracastReceiverMediaSourceCreatedEventArgs^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverMediaSourceCreatedEventArgs^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Deferral^ result;
          result = wrapper->_instance->GetDeferral();
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "Deferral", 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 ConnectionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverMediaSourceCreatedEventArgs^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverMediaSourceCreatedEventArgs^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverMediaSourceCreatedEventArgs^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Media::Core::MediaSource^ result = wrapper->_instance->MediaSource;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Media.Core", "MediaSource", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Miracast::MiracastReceiverMediaSourceCreatedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMiracastReceiverMediaSourceCreatedEventArgs(::Windows::Media::Miracast::MiracastReceiverMediaSourceCreatedEventArgs^ wintRtInstance);
      friend ::Windows::Media::Miracast::MiracastReceiverMediaSourceCreatedEventArgs^ UnwrapMiracastReceiverMediaSourceCreatedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> MiracastReceiverMediaSourceCreatedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapMiracastReceiverMediaSourceCreatedEventArgs(::Windows::Media::Miracast::MiracastReceiverMediaSourceCreatedEventArgs^ 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>(MiracastReceiverMediaSourceCreatedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Miracast::MiracastReceiverMediaSourceCreatedEventArgs^ UnwrapMiracastReceiverMediaSourceCreatedEventArgs(Local<Value> value) {
     return MiracastReceiverMediaSourceCreatedEventArgs::Unwrap<MiracastReceiverMediaSourceCreatedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMiracastReceiverMediaSourceCreatedEventArgs(Local<Object> exports) {
    MiracastReceiverMediaSourceCreatedEventArgs::Init(exports);
  }

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

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

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

          
            Nan::SetPrototypeMethod(localRef, "startAsync", StartAsync);
          

          
          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>("maxSimultaneousConnections").ToLocalChecked(), MaxSimultaneousConnectionsGetter, MaxSimultaneousConnectionsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("allowConnectionTakeover").ToLocalChecked(), AllowConnectionTakeoverGetter, AllowConnectionTakeoverSetter);

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



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

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

    private:

      MiracastReceiverSession(::Windows::Media::Miracast::MiracastReceiverSession^ 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::Media::Miracast::MiracastReceiverSession^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverSession^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Media::Miracast::MiracastReceiverSessionStartResult^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->StartAsync();
        }
        catch (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::Media::Miracast::MiracastReceiverSessionStartResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverSession^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Media::Miracast::MiracastReceiverSessionStartResult^ result;
          result = wrapper->_instance->Start();
          info.GetReturnValue().Set(WrapMiracastReceiverSessionStartResult(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::Media::Miracast::MiracastReceiverSession^>(info.This())) {
        return;
      }

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverSession^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverSession^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverSession^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->AllowConnectionTakeover;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AllowConnectionTakeoverSetter(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::Media::Miracast::MiracastReceiverSession^>(info.This())) {
        return;
      }

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

      try {

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

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


    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"connectionCreated", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverSession^>(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;
        }
        MiracastReceiverSession *wrapper = MiracastReceiverSession::Unwrap<MiracastReceiverSession>(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->ConnectionCreated::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Miracast::MiracastReceiverSession^, ::Windows::Media::Miracast::MiracastReceiverConnectionCreatedEventArgs^>(
            [callbackObjPtr](::Windows::Media::Miracast::MiracastReceiverSession^ arg0, ::Windows::Media::Miracast::MiracastReceiverConnectionCreatedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapMiracastReceiverSession(arg0);
                  wrappedArg1 = WrapMiracastReceiverConnectionCreatedEventArgs(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"disconnected", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverSession^>(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;
        }
        MiracastReceiverSession *wrapper = MiracastReceiverSession::Unwrap<MiracastReceiverSession>(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->Disconnected::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Miracast::MiracastReceiverSession^, ::Windows::Media::Miracast::MiracastReceiverDisconnectedEventArgs^>(
            [callbackObjPtr](::Windows::Media::Miracast::MiracastReceiverSession^ arg0, ::Windows::Media::Miracast::MiracastReceiverDisconnectedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapMiracastReceiverSession(arg0);
                  wrappedArg1 = WrapMiracastReceiverDisconnectedEventArgs(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"mediaSourceCreated", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverSession^>(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;
        }
        MiracastReceiverSession *wrapper = MiracastReceiverSession::Unwrap<MiracastReceiverSession>(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->MediaSourceCreated::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Miracast::MiracastReceiverSession^, ::Windows::Media::Miracast::MiracastReceiverMediaSourceCreatedEventArgs^>(
            [callbackObjPtr](::Windows::Media::Miracast::MiracastReceiverSession^ arg0, ::Windows::Media::Miracast::MiracastReceiverMediaSourceCreatedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapMiracastReceiverSession(arg0);
                  wrappedArg1 = WrapMiracastReceiverMediaSourceCreatedEventArgs(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"connectionCreated", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"disconnected", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"mediaSourceCreated", 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"connectionCreated", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverSession^>(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;
          }
          MiracastReceiverSession *wrapper = MiracastReceiverSession::Unwrap<MiracastReceiverSession>(info.This());
          wrapper->_instance->ConnectionCreated::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"disconnected", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverSession^>(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;
          }
          MiracastReceiverSession *wrapper = MiracastReceiverSession::Unwrap<MiracastReceiverSession>(info.This());
          wrapper->_instance->Disconnected::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"mediaSourceCreated", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverSession^>(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;
          }
          MiracastReceiverSession *wrapper = MiracastReceiverSession::Unwrap<MiracastReceiverSession>(info.This());
          wrapper->_instance->MediaSourceCreated::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::Media::Miracast::MiracastReceiverSession^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMiracastReceiverSession(::Windows::Media::Miracast::MiracastReceiverSession^ wintRtInstance);
      friend ::Windows::Media::Miracast::MiracastReceiverSession^ UnwrapMiracastReceiverSession(Local<Value> value);
  };

  Persistent<FunctionTemplate> MiracastReceiverSession::s_constructorTemplate;

  v8::Local<v8::Value> WrapMiracastReceiverSession(::Windows::Media::Miracast::MiracastReceiverSession^ 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>(MiracastReceiverSession::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Miracast::MiracastReceiverSession^ UnwrapMiracastReceiverSession(Local<Value> value) {
     return MiracastReceiverSession::Unwrap<MiracastReceiverSession>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMiracastReceiverSession(Local<Object> exports) {
    MiracastReceiverSession::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("extendedError").ToLocalChecked(), ExtendedErrorGetter);
            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>("MiracastReceiverSessionStartResult").ToLocalChecked(), constructor);
      }

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

    private:

      MiracastReceiverSessionStartResult(::Windows::Media::Miracast::MiracastReceiverSessionStartResult^ 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::Media::Miracast::MiracastReceiverSessionStartResult^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverSessionStartResult^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::HResult result = wrapper->_instance->ExtendedError;
        info.GetReturnValue().Set(Nan::New<Integer>(result.Value));
        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::Media::Miracast::MiracastReceiverSessionStartResult^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Media::Miracast::MiracastReceiverSessionStartStatus 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::Media::Miracast::MiracastReceiverSessionStartResult^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMiracastReceiverSessionStartResult(::Windows::Media::Miracast::MiracastReceiverSessionStartResult^ wintRtInstance);
      friend ::Windows::Media::Miracast::MiracastReceiverSessionStartResult^ UnwrapMiracastReceiverSessionStartResult(Local<Value> value);
  };

  Persistent<FunctionTemplate> MiracastReceiverSessionStartResult::s_constructorTemplate;

  v8::Local<v8::Value> WrapMiracastReceiverSessionStartResult(::Windows::Media::Miracast::MiracastReceiverSessionStartResult^ 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>(MiracastReceiverSessionStartResult::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Miracast::MiracastReceiverSessionStartResult^ UnwrapMiracastReceiverSessionStartResult(Local<Value> value) {
     return MiracastReceiverSessionStartResult::Unwrap<MiracastReceiverSessionStartResult>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMiracastReceiverSessionStartResult(Local<Object> exports) {
    MiracastReceiverSessionStartResult::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("requireAuthorizationFromKnownTransmitters").ToLocalChecked(), RequireAuthorizationFromKnownTransmittersGetter, RequireAuthorizationFromKnownTransmittersSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("modelNumber").ToLocalChecked(), ModelNumberGetter, ModelNumberSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("modelName").ToLocalChecked(), ModelNameGetter, ModelNameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("friendlyName").ToLocalChecked(), FriendlyNameGetter, FriendlyNameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("authorizationMethod").ToLocalChecked(), AuthorizationMethodGetter, AuthorizationMethodSetter);

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



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

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

    private:

      MiracastReceiverSettings(::Windows::Media::Miracast::MiracastReceiverSettings^ 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::Media::Miracast::MiracastReceiverSettings^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverSettings^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->RequireAuthorizationFromKnownTransmitters;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RequireAuthorizationFromKnownTransmittersSetter(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::Media::Miracast::MiracastReceiverSettings^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverSettings^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverSettings^>(info.This())) {
        return;
      }

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

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverSettings^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverSettings^>(info.This())) {
        return;
      }

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

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverSettings^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverSettings^>(info.This())) {
        return;
      }

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

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverSettings^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverSettings^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Media::Miracast::MiracastReceiverAuthorizationMethod winRtValue = static_cast<::Windows::Media::Miracast::MiracastReceiverAuthorizationMethod>(Nan::To<int32_t>(value).FromMaybe(0));

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


    private:
      ::Windows::Media::Miracast::MiracastReceiverSettings^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMiracastReceiverSettings(::Windows::Media::Miracast::MiracastReceiverSettings^ wintRtInstance);
      friend ::Windows::Media::Miracast::MiracastReceiverSettings^ UnwrapMiracastReceiverSettings(Local<Value> value);
  };

  Persistent<FunctionTemplate> MiracastReceiverSettings::s_constructorTemplate;

  v8::Local<v8::Value> WrapMiracastReceiverSettings(::Windows::Media::Miracast::MiracastReceiverSettings^ 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>(MiracastReceiverSettings::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Miracast::MiracastReceiverSettings^ UnwrapMiracastReceiverSettings(Local<Value> value) {
     return MiracastReceiverSettings::Unwrap<MiracastReceiverSettings>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMiracastReceiverSettings(Local<Object> exports) {
    MiracastReceiverSettings::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isConnectionTakeoverSupported").ToLocalChecked(), IsConnectionTakeoverSupportedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("knownTransmitters").ToLocalChecked(), KnownTransmittersGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("listeningStatus").ToLocalChecked(), ListeningStatusGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxSimultaneousConnections").ToLocalChecked(), MaxSimultaneousConnectionsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("wiFiStatus").ToLocalChecked(), WiFiStatusGetter);

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



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

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

    private:

      MiracastReceiverStatus(::Windows::Media::Miracast::MiracastReceiverStatus^ 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::Media::Miracast::MiracastReceiverStatus^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverStatus^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverStatus^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Media::Miracast::MiracastTransmitter^>^ result = wrapper->_instance->KnownTransmitters;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Media::Miracast::MiracastTransmitter^>::CreateVectorViewWrapper(result, 
            [](::Windows::Media::Miracast::MiracastTransmitter^ val) -> Local<Value> {
              return WrapMiracastTransmitter(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastTransmitter^>(value);
            },
            [](Local<Value> value) -> ::Windows::Media::Miracast::MiracastTransmitter^ {
              return UnwrapMiracastTransmitter(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ListeningStatusGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverStatus^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverStatus^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverStatus^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Media::Miracast::MiracastReceiverStatus^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMiracastReceiverStatus(::Windows::Media::Miracast::MiracastReceiverStatus^ wintRtInstance);
      friend ::Windows::Media::Miracast::MiracastReceiverStatus^ UnwrapMiracastReceiverStatus(Local<Value> value);
  };

  Persistent<FunctionTemplate> MiracastReceiverStatus::s_constructorTemplate;

  v8::Local<v8::Value> WrapMiracastReceiverStatus(::Windows::Media::Miracast::MiracastReceiverStatus^ 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>(MiracastReceiverStatus::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Miracast::MiracastReceiverStatus^ UnwrapMiracastReceiverStatus(Local<Value> value) {
     return MiracastReceiverStatus::Unwrap<MiracastReceiverStatus>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMiracastReceiverStatus(Local<Object> exports) {
    MiracastReceiverStatus::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "getVideoStreamSettings", GetVideoStreamSettings);
            Nan::SetPrototypeMethod(localRef, "suggestVideoStreamSettings", SuggestVideoStreamSettings);
          

          
            Nan::SetPrototypeMethod(localRef, "getVideoStreamSettingsAsync", GetVideoStreamSettingsAsync);
            Nan::SetPrototypeMethod(localRef, "suggestVideoStreamSettingsAsync", SuggestVideoStreamSettingsAsync);
          


          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("muteAudio").ToLocalChecked(), MuteAudioGetter, MuteAudioSetter);

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



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

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

    private:

      MiracastReceiverStreamControl(::Windows::Media::Miracast::MiracastReceiverStreamControl^ 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::Media::Miracast::MiracastReceiverStreamControl^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverStreamControl^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Media::Miracast::MiracastReceiverVideoStreamSettings^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->GetVideoStreamSettingsAsync();
        }
        catch (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::Media::Miracast::MiracastReceiverVideoStreamSettings^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverStreamControl^>(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;
      }

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

      ::Windows::Foundation::IAsyncAction^ op;


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

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

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


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


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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverStreamControl^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Media::Miracast::MiracastReceiverVideoStreamSettings^ result;
          result = wrapper->_instance->GetVideoStreamSettings();
          info.GetReturnValue().Set(WrapMiracastReceiverVideoStreamSettings(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 SuggestVideoStreamSettings(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverStreamControl^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverVideoStreamSettings^>(info[0]))
      {
        try
        {
          ::Windows::Media::Miracast::MiracastReceiverVideoStreamSettings^ arg0 = UnwrapMiracastReceiverVideoStreamSettings(info[0]);
          
          wrapper->_instance->SuggestVideoStreamSettings(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverStreamControl^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->MuteAudio;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MuteAudioSetter(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::Media::Miracast::MiracastReceiverStreamControl^>(info.This())) {
        return;
      }

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

      try {

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

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


    private:
      ::Windows::Media::Miracast::MiracastReceiverStreamControl^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMiracastReceiverStreamControl(::Windows::Media::Miracast::MiracastReceiverStreamControl^ wintRtInstance);
      friend ::Windows::Media::Miracast::MiracastReceiverStreamControl^ UnwrapMiracastReceiverStreamControl(Local<Value> value);
  };

  Persistent<FunctionTemplate> MiracastReceiverStreamControl::s_constructorTemplate;

  v8::Local<v8::Value> WrapMiracastReceiverStreamControl(::Windows::Media::Miracast::MiracastReceiverStreamControl^ 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>(MiracastReceiverStreamControl::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Miracast::MiracastReceiverStreamControl^ UnwrapMiracastReceiverStreamControl(Local<Value> value) {
     return MiracastReceiverStreamControl::Unwrap<MiracastReceiverStreamControl>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMiracastReceiverStreamControl(Local<Object> exports) {
    MiracastReceiverStreamControl::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("size").ToLocalChecked(), SizeGetter, SizeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("bitrate").ToLocalChecked(), BitrateGetter, BitrateSetter);

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



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

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

    private:

      MiracastReceiverVideoStreamSettings(::Windows::Media::Miracast::MiracastReceiverVideoStreamSettings^ 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::Media::Miracast::MiracastReceiverVideoStreamSettings^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverVideoStreamSettings^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverVideoStreamSettings^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Graphics::SizeInt32 winRtValue = SizeInt32FromJsObject(value);

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverVideoStreamSettings^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastReceiverVideoStreamSettings^>(info.This())) {
        return;
      }

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

      try {

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

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


    private:
      ::Windows::Media::Miracast::MiracastReceiverVideoStreamSettings^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMiracastReceiverVideoStreamSettings(::Windows::Media::Miracast::MiracastReceiverVideoStreamSettings^ wintRtInstance);
      friend ::Windows::Media::Miracast::MiracastReceiverVideoStreamSettings^ UnwrapMiracastReceiverVideoStreamSettings(Local<Value> value);
  };

  Persistent<FunctionTemplate> MiracastReceiverVideoStreamSettings::s_constructorTemplate;

  v8::Local<v8::Value> WrapMiracastReceiverVideoStreamSettings(::Windows::Media::Miracast::MiracastReceiverVideoStreamSettings^ 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>(MiracastReceiverVideoStreamSettings::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Miracast::MiracastReceiverVideoStreamSettings^ UnwrapMiracastReceiverVideoStreamSettings(Local<Value> value) {
     return MiracastReceiverVideoStreamSettings::Unwrap<MiracastReceiverVideoStreamSettings>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMiracastReceiverVideoStreamSettings(Local<Object> exports) {
    MiracastReceiverVideoStreamSettings::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getConnections", GetConnections);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("name").ToLocalChecked(), NameGetter, NameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("authorizationStatus").ToLocalChecked(), AuthorizationStatusGetter, AuthorizationStatusSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("lastConnectionTime").ToLocalChecked(), LastConnectionTimeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("macAddress").ToLocalChecked(), MacAddressGetter);

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



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

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

    private:

      MiracastTransmitter(::Windows::Media::Miracast::MiracastTransmitter^ 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::Media::Miracast::MiracastTransmitter^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastTransmitter^>(info.This())) {
        return;
      }

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

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



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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastTransmitter^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastTransmitter^>(info.This())) {
        return;
      }

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

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastTransmitter^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastTransmitter^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Media::Miracast::MiracastTransmitterAuthorizationStatus winRtValue = static_cast<::Windows::Media::Miracast::MiracastTransmitterAuthorizationStatus>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastTransmitter^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Miracast::MiracastTransmitter^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Media::Miracast::MiracastTransmitter^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMiracastTransmitter(::Windows::Media::Miracast::MiracastTransmitter^ wintRtInstance);
      friend ::Windows::Media::Miracast::MiracastTransmitter^ UnwrapMiracastTransmitter(Local<Value> value);
  };

  Persistent<FunctionTemplate> MiracastTransmitter::s_constructorTemplate;

  v8::Local<v8::Value> WrapMiracastTransmitter(::Windows::Media::Miracast::MiracastTransmitter^ 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>(MiracastTransmitter::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Miracast::MiracastTransmitter^ UnwrapMiracastTransmitter(Local<Value> value) {
     return MiracastTransmitter::Unwrap<MiracastTransmitter>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMiracastTransmitter(Local<Object> exports) {
    MiracastTransmitter::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::Media::Miracast::InitMiracastReceiverApplySettingsStatusEnum(target);
      NodeRT::Windows::Media::Miracast::InitMiracastReceiverAuthorizationMethodEnum(target);
      NodeRT::Windows::Media::Miracast::InitMiracastReceiverDisconnectReasonEnum(target);
      NodeRT::Windows::Media::Miracast::InitMiracastReceiverGameControllerDeviceUsageModeEnum(target);
      NodeRT::Windows::Media::Miracast::InitMiracastReceiverListeningStatusEnum(target);
      NodeRT::Windows::Media::Miracast::InitMiracastReceiverSessionStartStatusEnum(target);
      NodeRT::Windows::Media::Miracast::InitMiracastReceiverWiFiStatusEnum(target);
      NodeRT::Windows::Media::Miracast::InitMiracastTransmitterAuthorizationStatusEnum(target);
      NodeRT::Windows::Media::Miracast::InitMiracastReceiver(target);
      NodeRT::Windows::Media::Miracast::InitMiracastReceiverApplySettingsResult(target);
      NodeRT::Windows::Media::Miracast::InitMiracastReceiverConnection(target);
      NodeRT::Windows::Media::Miracast::InitMiracastReceiverConnectionCreatedEventArgs(target);
      NodeRT::Windows::Media::Miracast::InitMiracastReceiverCursorImageChannel(target);
      NodeRT::Windows::Media::Miracast::InitMiracastReceiverCursorImageChannelSettings(target);
      NodeRT::Windows::Media::Miracast::InitMiracastReceiverDisconnectedEventArgs(target);
      NodeRT::Windows::Media::Miracast::InitMiracastReceiverGameControllerDevice(target);
      NodeRT::Windows::Media::Miracast::InitMiracastReceiverInputDevices(target);
      NodeRT::Windows::Media::Miracast::InitMiracastReceiverKeyboardDevice(target);
      NodeRT::Windows::Media::Miracast::InitMiracastReceiverMediaSourceCreatedEventArgs(target);
      NodeRT::Windows::Media::Miracast::InitMiracastReceiverSession(target);
      NodeRT::Windows::Media::Miracast::InitMiracastReceiverSessionStartResult(target);
      NodeRT::Windows::Media::Miracast::InitMiracastReceiverSettings(target);
      NodeRT::Windows::Media::Miracast::InitMiracastReceiverStatus(target);
      NodeRT::Windows::Media::Miracast::InitMiracastReceiverStreamControl(target);
      NodeRT::Windows::Media::Miracast::InitMiracastReceiverVideoStreamSettings(target);
      NodeRT::Windows::Media::Miracast::InitMiracastTransmitter(target);


  NodeRT::Utils::RegisterNameSpace("Windows.Media.Miracast", target);
}



NODE_MODULE(binding, init)