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

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

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

#using <Windows.WinMD>

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

const char* REGISTRATION_TOKEN_MAP_PROPERTY_NAME = "__registrationTokenMap__";

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

namespace NodeRT { namespace Windows { namespace Devices { namespace AllJoyn { 
  v8::Local<v8::Value> WrapAllJoynStatus(::Windows::Devices::AllJoyn::AllJoynStatus^ wintRtInstance);
  ::Windows::Devices::AllJoyn::AllJoynStatus^ UnwrapAllJoynStatus(Local<Value> value);
  
  v8::Local<v8::Value> WrapAllJoynAboutData(::Windows::Devices::AllJoyn::AllJoynAboutData^ wintRtInstance);
  ::Windows::Devices::AllJoyn::AllJoynAboutData^ UnwrapAllJoynAboutData(Local<Value> value);
  
  v8::Local<v8::Value> WrapAllJoynBusAttachment(::Windows::Devices::AllJoyn::AllJoynBusAttachment^ wintRtInstance);
  ::Windows::Devices::AllJoyn::AllJoynBusAttachment^ UnwrapAllJoynBusAttachment(Local<Value> value);
  
  v8::Local<v8::Value> WrapAllJoynBusAttachmentStateChangedEventArgs(::Windows::Devices::AllJoyn::AllJoynBusAttachmentStateChangedEventArgs^ wintRtInstance);
  ::Windows::Devices::AllJoyn::AllJoynBusAttachmentStateChangedEventArgs^ UnwrapAllJoynBusAttachmentStateChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapAllJoynCredentialsRequestedEventArgs(::Windows::Devices::AllJoyn::AllJoynCredentialsRequestedEventArgs^ wintRtInstance);
  ::Windows::Devices::AllJoyn::AllJoynCredentialsRequestedEventArgs^ UnwrapAllJoynCredentialsRequestedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapAllJoynCredentialsVerificationRequestedEventArgs(::Windows::Devices::AllJoyn::AllJoynCredentialsVerificationRequestedEventArgs^ wintRtInstance);
  ::Windows::Devices::AllJoyn::AllJoynCredentialsVerificationRequestedEventArgs^ UnwrapAllJoynCredentialsVerificationRequestedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapAllJoynAuthenticationCompleteEventArgs(::Windows::Devices::AllJoyn::AllJoynAuthenticationCompleteEventArgs^ wintRtInstance);
  ::Windows::Devices::AllJoyn::AllJoynAuthenticationCompleteEventArgs^ UnwrapAllJoynAuthenticationCompleteEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapAllJoynServiceInfo(::Windows::Devices::AllJoyn::AllJoynServiceInfo^ wintRtInstance);
  ::Windows::Devices::AllJoyn::AllJoynServiceInfo^ UnwrapAllJoynServiceInfo(Local<Value> value);
  
  v8::Local<v8::Value> WrapAllJoynAboutDataView(::Windows::Devices::AllJoyn::AllJoynAboutDataView^ wintRtInstance);
  ::Windows::Devices::AllJoyn::AllJoynAboutDataView^ UnwrapAllJoynAboutDataView(Local<Value> value);
  
  v8::Local<v8::Value> WrapAllJoynAcceptSessionJoinerEventArgs(::Windows::Devices::AllJoyn::AllJoynAcceptSessionJoinerEventArgs^ wintRtInstance);
  ::Windows::Devices::AllJoyn::AllJoynAcceptSessionJoinerEventArgs^ UnwrapAllJoynAcceptSessionJoinerEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapAllJoynSessionJoinedEventArgs(::Windows::Devices::AllJoyn::AllJoynSessionJoinedEventArgs^ wintRtInstance);
  ::Windows::Devices::AllJoyn::AllJoynSessionJoinedEventArgs^ UnwrapAllJoynSessionJoinedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapAllJoynCredentials(::Windows::Devices::AllJoyn::AllJoynCredentials^ wintRtInstance);
  ::Windows::Devices::AllJoyn::AllJoynCredentials^ UnwrapAllJoynCredentials(Local<Value> value);
  
  v8::Local<v8::Value> WrapAllJoynSession(::Windows::Devices::AllJoyn::AllJoynSession^ wintRtInstance);
  ::Windows::Devices::AllJoyn::AllJoynSession^ UnwrapAllJoynSession(Local<Value> value);
  
  v8::Local<v8::Value> WrapAllJoynSessionMemberAddedEventArgs(::Windows::Devices::AllJoyn::AllJoynSessionMemberAddedEventArgs^ wintRtInstance);
  ::Windows::Devices::AllJoyn::AllJoynSessionMemberAddedEventArgs^ UnwrapAllJoynSessionMemberAddedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapAllJoynSessionMemberRemovedEventArgs(::Windows::Devices::AllJoyn::AllJoynSessionMemberRemovedEventArgs^ wintRtInstance);
  ::Windows::Devices::AllJoyn::AllJoynSessionMemberRemovedEventArgs^ UnwrapAllJoynSessionMemberRemovedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapAllJoynSessionLostEventArgs(::Windows::Devices::AllJoyn::AllJoynSessionLostEventArgs^ wintRtInstance);
  ::Windows::Devices::AllJoyn::AllJoynSessionLostEventArgs^ UnwrapAllJoynSessionLostEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapIAllJoynProducer(::Windows::Devices::AllJoyn::IAllJoynProducer^ wintRtInstance);
  ::Windows::Devices::AllJoyn::IAllJoynProducer^ UnwrapIAllJoynProducer(Local<Value> value);
  
  v8::Local<v8::Value> WrapAllJoynBusObject(::Windows::Devices::AllJoyn::AllJoynBusObject^ wintRtInstance);
  ::Windows::Devices::AllJoyn::AllJoynBusObject^ UnwrapAllJoynBusObject(Local<Value> value);
  
  v8::Local<v8::Value> WrapAllJoynBusObjectStoppedEventArgs(::Windows::Devices::AllJoyn::AllJoynBusObjectStoppedEventArgs^ wintRtInstance);
  ::Windows::Devices::AllJoyn::AllJoynBusObjectStoppedEventArgs^ UnwrapAllJoynBusObjectStoppedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapIAllJoynAcceptSessionJoiner(::Windows::Devices::AllJoyn::IAllJoynAcceptSessionJoiner^ wintRtInstance);
  ::Windows::Devices::AllJoyn::IAllJoynAcceptSessionJoiner^ UnwrapIAllJoynAcceptSessionJoiner(Local<Value> value);
  
  v8::Local<v8::Value> WrapAllJoynProducerStoppedEventArgs(::Windows::Devices::AllJoyn::AllJoynProducerStoppedEventArgs^ wintRtInstance);
  ::Windows::Devices::AllJoyn::AllJoynProducerStoppedEventArgs^ UnwrapAllJoynProducerStoppedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapAllJoynWatcherStoppedEventArgs(::Windows::Devices::AllJoyn::AllJoynWatcherStoppedEventArgs^ wintRtInstance);
  ::Windows::Devices::AllJoyn::AllJoynWatcherStoppedEventArgs^ UnwrapAllJoynWatcherStoppedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapAllJoynServiceInfoRemovedEventArgs(::Windows::Devices::AllJoyn::AllJoynServiceInfoRemovedEventArgs^ wintRtInstance);
  ::Windows::Devices::AllJoyn::AllJoynServiceInfoRemovedEventArgs^ UnwrapAllJoynServiceInfoRemovedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapAllJoynMessageInfo(::Windows::Devices::AllJoyn::AllJoynMessageInfo^ wintRtInstance);
  ::Windows::Devices::AllJoyn::AllJoynMessageInfo^ UnwrapAllJoynMessageInfo(Local<Value> value);
  



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

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

    Nan::Set(exports, Nan::New<String>("AllJoynAuthenticationMechanism").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::AllJoyn::AllJoynAuthenticationMechanism::None)));
    Nan::Set(enumObject, Nan::New<String>("srpAnonymous").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::AllJoyn::AllJoynAuthenticationMechanism::SrpAnonymous)));
    Nan::Set(enumObject, Nan::New<String>("srpLogon").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::AllJoyn::AllJoynAuthenticationMechanism::SrpLogon)));
    Nan::Set(enumObject, Nan::New<String>("ecdheNull").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::AllJoyn::AllJoynAuthenticationMechanism::EcdheNull)));
    Nan::Set(enumObject, Nan::New<String>("ecdhePsk").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::AllJoyn::AllJoynAuthenticationMechanism::EcdhePsk)));
    Nan::Set(enumObject, Nan::New<String>("ecdheEcdsa").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::AllJoyn::AllJoynAuthenticationMechanism::EcdheEcdsa)));
    Nan::Set(enumObject, Nan::New<String>("ecdheSpeke").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::AllJoyn::AllJoynAuthenticationMechanism::EcdheSpeke)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("AllJoynBusAttachmentState").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("disconnected").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::AllJoyn::AllJoynBusAttachmentState::Disconnected)));
    Nan::Set(enumObject, Nan::New<String>("connecting").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::AllJoyn::AllJoynBusAttachmentState::Connecting)));
    Nan::Set(enumObject, Nan::New<String>("connected").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::AllJoyn::AllJoynBusAttachmentState::Connected)));
    Nan::Set(enumObject, Nan::New<String>("disconnecting").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::AllJoyn::AllJoynBusAttachmentState::Disconnecting)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("AllJoynTrafficType").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("unknown").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::AllJoyn::AllJoynTrafficType::Unknown)));
    Nan::Set(enumObject, Nan::New<String>("messages").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::AllJoyn::AllJoynTrafficType::Messages)));
    Nan::Set(enumObject, Nan::New<String>("rawUnreliable").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::AllJoyn::AllJoynTrafficType::RawUnreliable)));
    Nan::Set(enumObject, Nan::New<String>("rawReliable").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::AllJoyn::AllJoynTrafficType::RawReliable)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("AllJoynSessionLostReason").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::AllJoyn::AllJoynSessionLostReason::None)));
    Nan::Set(enumObject, Nan::New<String>("producerLeftSession").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::AllJoyn::AllJoynSessionLostReason::ProducerLeftSession)));
    Nan::Set(enumObject, Nan::New<String>("producerClosedAbruptly").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::AllJoyn::AllJoynSessionLostReason::ProducerClosedAbruptly)));
    Nan::Set(enumObject, Nan::New<String>("removedByProducer").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::AllJoyn::AllJoynSessionLostReason::RemovedByProducer)));
    Nan::Set(enumObject, Nan::New<String>("linkTimeout").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::AllJoyn::AllJoynSessionLostReason::LinkTimeout)));
    Nan::Set(enumObject, Nan::New<String>("other").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Devices::AllJoyn::AllJoynSessionLostReason::Other)));
  }



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






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

        Nan::SetAccessor(constructor, Nan::New<String>("authenticationFailed").ToLocalChecked(), AuthenticationFailedGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("authenticationRejectedByUser").ToLocalChecked(), AuthenticationRejectedByUserGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("connectionRefused").ToLocalChecked(), ConnectionRefusedGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("fail").ToLocalChecked(), FailGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("insufficientSecurity").ToLocalChecked(), InsufficientSecurityGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("invalidArgument1").ToLocalChecked(), InvalidArgument1Getter);
        Nan::SetAccessor(constructor, Nan::New<String>("invalidArgument2").ToLocalChecked(), InvalidArgument2Getter);
        Nan::SetAccessor(constructor, Nan::New<String>("invalidArgument3").ToLocalChecked(), InvalidArgument3Getter);
        Nan::SetAccessor(constructor, Nan::New<String>("invalidArgument4").ToLocalChecked(), InvalidArgument4Getter);
        Nan::SetAccessor(constructor, Nan::New<String>("invalidArgument5").ToLocalChecked(), InvalidArgument5Getter);
        Nan::SetAccessor(constructor, Nan::New<String>("invalidArgument6").ToLocalChecked(), InvalidArgument6Getter);
        Nan::SetAccessor(constructor, Nan::New<String>("invalidArgument7").ToLocalChecked(), InvalidArgument7Getter);
        Nan::SetAccessor(constructor, Nan::New<String>("invalidArgument8").ToLocalChecked(), InvalidArgument8Getter);
        Nan::SetAccessor(constructor, Nan::New<String>("ok").ToLocalChecked(), OkGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("operationTimedOut").ToLocalChecked(), OperationTimedOutGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("otherEndClosed").ToLocalChecked(), OtherEndClosedGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("sslConnectFailed").ToLocalChecked(), SslConnectFailedGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("sslIdentityVerificationFailed").ToLocalChecked(), SslIdentityVerificationFailedGetter);


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

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

    private:

      AllJoynStatus(::Windows::Devices::AllJoyn::AllJoynStatus^ instance) {
        _instance = instance;
      }

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

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::Devices::AllJoyn::AllJoynStatus^ winRtInstance;


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

      AllJoynStatus *wrapperInstance = new AllJoynStatus(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynStatus^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::Devices::AllJoyn::AllJoynStatus^ winRtInstance;
      try {
        winRtInstance = (::Windows::Devices::AllJoyn::AllJoynStatus^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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







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

      try
      {
        int result = ::Windows::Devices::AllJoyn::AllJoynStatus::AuthenticationFailed;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        int result = ::Windows::Devices::AllJoyn::AllJoynStatus::AuthenticationRejectedByUser;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        int result = ::Windows::Devices::AllJoyn::AllJoynStatus::ConnectionRefused;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        int result = ::Windows::Devices::AllJoyn::AllJoynStatus::Fail;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        int result = ::Windows::Devices::AllJoyn::AllJoynStatus::InsufficientSecurity;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        int result = ::Windows::Devices::AllJoyn::AllJoynStatus::InvalidArgument1;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        int result = ::Windows::Devices::AllJoyn::AllJoynStatus::InvalidArgument2;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        int result = ::Windows::Devices::AllJoyn::AllJoynStatus::InvalidArgument3;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        int result = ::Windows::Devices::AllJoyn::AllJoynStatus::InvalidArgument4;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        int result = ::Windows::Devices::AllJoyn::AllJoynStatus::InvalidArgument5;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        int result = ::Windows::Devices::AllJoyn::AllJoynStatus::InvalidArgument6;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        int result = ::Windows::Devices::AllJoyn::AllJoynStatus::InvalidArgument7;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        int result = ::Windows::Devices::AllJoyn::AllJoynStatus::InvalidArgument8;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        int result = ::Windows::Devices::AllJoyn::AllJoynStatus::Ok;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        int result = ::Windows::Devices::AllJoyn::AllJoynStatus::OperationTimedOut;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        int result = ::Windows::Devices::AllJoyn::AllJoynStatus::OtherEndClosed;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        int result = ::Windows::Devices::AllJoyn::AllJoynStatus::SslConnectFailed;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        int result = ::Windows::Devices::AllJoyn::AllJoynStatus::SslIdentityVerificationFailed;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    private:
      ::Windows::Devices::AllJoyn::AllJoynStatus^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAllJoynStatus(::Windows::Devices::AllJoyn::AllJoynStatus^ wintRtInstance);
      friend ::Windows::Devices::AllJoyn::AllJoynStatus^ UnwrapAllJoynStatus(Local<Value> value);
  };

  Persistent<FunctionTemplate> AllJoynStatus::s_constructorTemplate;

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

  ::Windows::Devices::AllJoyn::AllJoynStatus^ UnwrapAllJoynStatus(Local<Value> value) {
     return AllJoynStatus::Unwrap<AllJoynStatus>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAllJoynStatus(Local<Object> exports) {
    AllJoynStatus::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("defaultDescription").ToLocalChecked(), DefaultDescriptionGetter, DefaultDescriptionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("defaultAppName").ToLocalChecked(), DefaultAppNameGetter, DefaultAppNameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dateOfManufacture").ToLocalChecked(), DateOfManufactureGetter, DateOfManufactureSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("defaultManufacturer").ToLocalChecked(), DefaultManufacturerGetter, DefaultManufacturerSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("appId").ToLocalChecked(), AppIdGetter, AppIdSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("supportUrl").ToLocalChecked(), SupportUrlGetter, SupportUrlSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("softwareVersion").ToLocalChecked(), SoftwareVersionGetter, SoftwareVersionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("modelNumber").ToLocalChecked(), ModelNumberGetter, ModelNumberSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isEnabled").ToLocalChecked(), IsEnabledGetter, IsEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("appNames").ToLocalChecked(), AppNamesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("manufacturers").ToLocalChecked(), ManufacturersGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("descriptions").ToLocalChecked(), DescriptionsGetter);

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



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

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

    private:

      AllJoynAboutData(::Windows::Devices::AllJoyn::AllJoynAboutData^ instance) {
        _instance = instance;
      }

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

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::Devices::AllJoyn::AllJoynAboutData^ winRtInstance;


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

      AllJoynAboutData *wrapperInstance = new AllJoynAboutData(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynAboutData^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::Devices::AllJoyn::AllJoynAboutData^ winRtInstance;
      try {
        winRtInstance = (::Windows::Devices::AllJoyn::AllJoynAboutData^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

      try  {
        Platform::String^ result = wrapper->_instance->DefaultDescription;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DefaultDescriptionSetter(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::Devices::AllJoyn::AllJoynAboutData^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

      try  {
        Platform::String^ result = wrapper->_instance->DefaultAppName;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DefaultAppNameSetter(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::Devices::AllJoyn::AllJoynAboutData^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

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

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

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

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

      try {

        ::Platform::IBox<::Windows::Foundation::DateTime>^ winRtValue = ref new ::Platform::Box<::Windows::Foundation::DateTime>(NodeRT::Utils::DateTimeFromJSDate(value));

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

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

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

      try  {
        Platform::String^ result = wrapper->_instance->DefaultManufacturer;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DefaultManufacturerSetter(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::Devices::AllJoyn::AllJoynAboutData^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

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

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

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

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

      try {

        ::Platform::Guid winRtValue = NodeRT::Utils::GuidFromJs(value);

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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

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

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

      try {

        ::Windows::Foundation::Uri^ winRtValue = dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(value));

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

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

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

      try  {
        Platform::String^ result = wrapper->_instance->SoftwareVersion;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SoftwareVersionSetter(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::Devices::AllJoyn::AllJoynAboutData^>(info.This())) {
        return;
      }

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

      try {

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

        wrapper->_instance->SoftwareVersion = 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::Devices::AllJoyn::AllJoynAboutData^>(info.This())) {
        return;
      }

      AllJoynAboutData *wrapper = AllJoynAboutData::Unwrap<AllJoynAboutData>(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::Devices::AllJoyn::AllJoynAboutData^>(info.This())) {
        return;
      }

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

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

      AllJoynAboutData *wrapper = AllJoynAboutData::Unwrap<AllJoynAboutData>(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::Devices::AllJoyn::AllJoynAboutData^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

      try  {
        ::Windows::Foundation::Collections::IMap<::Platform::String^, ::Platform::String^>^ result = wrapper->_instance->AppNames;
        info.GetReturnValue().Set(NodeRT::Collections::MapWrapper<::Platform::String^,::Platform::String^>::CreateMapWrapper(result, 
            [](::Platform::String^ val) -> Local<Value> {
              return NodeRT::Utils::NewString(val->Data());
            },
            [](Local<Value> value) -> bool {
              return value->IsString();
            },
            [](Local<Value> value) -> ::Platform::String^ {
              return ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));
            },
            [](::Platform::String^ val) -> Local<Value> {
              return NodeRT::Utils::NewString(val->Data());
            },
            [](Local<Value> value) -> bool {
              return value->IsString();
            },
            [](Local<Value> value) -> ::Platform::String^ {
              return ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ManufacturersGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

      try  {
        ::Windows::Foundation::Collections::IMap<::Platform::String^, ::Platform::String^>^ result = wrapper->_instance->Manufacturers;
        info.GetReturnValue().Set(NodeRT::Collections::MapWrapper<::Platform::String^,::Platform::String^>::CreateMapWrapper(result, 
            [](::Platform::String^ val) -> Local<Value> {
              return NodeRT::Utils::NewString(val->Data());
            },
            [](Local<Value> value) -> bool {
              return value->IsString();
            },
            [](Local<Value> value) -> ::Platform::String^ {
              return ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));
            },
            [](::Platform::String^ val) -> Local<Value> {
              return NodeRT::Utils::NewString(val->Data());
            },
            [](Local<Value> value) -> bool {
              return value->IsString();
            },
            [](Local<Value> value) -> ::Platform::String^ {
              return ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DescriptionsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

      try  {
        ::Windows::Foundation::Collections::IMap<::Platform::String^, ::Platform::String^>^ result = wrapper->_instance->Descriptions;
        info.GetReturnValue().Set(NodeRT::Collections::MapWrapper<::Platform::String^,::Platform::String^>::CreateMapWrapper(result, 
            [](::Platform::String^ val) -> Local<Value> {
              return NodeRT::Utils::NewString(val->Data());
            },
            [](Local<Value> value) -> bool {
              return value->IsString();
            },
            [](Local<Value> value) -> ::Platform::String^ {
              return ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));
            },
            [](::Platform::String^ val) -> Local<Value> {
              return NodeRT::Utils::NewString(val->Data());
            },
            [](Local<Value> value) -> bool {
              return value->IsString();
            },
            [](Local<Value> value) -> ::Platform::String^ {
              return ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Devices::AllJoyn::AllJoynAboutData^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAllJoynAboutData(::Windows::Devices::AllJoyn::AllJoynAboutData^ wintRtInstance);
      friend ::Windows::Devices::AllJoyn::AllJoynAboutData^ UnwrapAllJoynAboutData(Local<Value> value);
  };

  Persistent<FunctionTemplate> AllJoynAboutData::s_constructorTemplate;

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

  ::Windows::Devices::AllJoyn::AllJoynAboutData^ UnwrapAllJoynAboutData(Local<Value> value) {
     return AllJoynAboutData::Unwrap<AllJoynAboutData>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAllJoynAboutData(Local<Object> exports) {
    AllJoynAboutData::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "connect", Connect);
            Nan::SetPrototypeMethod(localRef, "disconnect", Disconnect);
          

          
            Nan::SetPrototypeMethod(localRef, "pingAsync", PingAsync);
            Nan::SetPrototypeMethod(localRef, "getAboutDataAsync", GetAboutDataAsync);
          

          
          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>("aboutData").ToLocalChecked(), AboutDataGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("authenticationMechanisms").ToLocalChecked(), AuthenticationMechanismsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("connectionSpecification").ToLocalChecked(), ConnectionSpecificationGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("state").ToLocalChecked(), StateGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("uniqueName").ToLocalChecked(), UniqueNameGetter);

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

        Nan::SetMethod(constructor, "getDefault", GetDefault);
        Nan::SetMethod(constructor, "getWatcher", GetWatcher);


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

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

    private:

      AllJoynBusAttachment(::Windows::Devices::AllJoyn::AllJoynBusAttachment^ instance) {
        _instance = instance;
      }

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

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::Devices::AllJoyn::AllJoynBusAttachment^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynBusAttachment^>(info[0])) {
        try {
          winRtInstance = (::Windows::Devices::AllJoyn::AllJoynBusAttachment^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && info[0]->IsString())
      {
        try {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          winRtInstance = ref new ::Windows::Devices::AllJoyn::AllJoynBusAttachment(arg0);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::Devices::AllJoyn::AllJoynBusAttachment();
        } 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());

      AllJoynBusAttachment *wrapperInstance = new AllJoynBusAttachment(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynBusAttachment^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::Devices::AllJoyn::AllJoynBusAttachment^ winRtInstance;
      try {
        winRtInstance = (::Windows::Devices::AllJoyn::AllJoynBusAttachment^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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

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

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

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

      ::Windows::Foundation::IAsyncOperation<int>^ op;


      if (info.Length() == 2
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          op = wrapper->_instance->PingAsync(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<int> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Devices::AllJoyn::AllJoynAboutDataView^>^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynServiceInfo^>(info[0]))
      {
        try
        {
          ::Windows::Devices::AllJoyn::AllJoynServiceInfo^ arg0 = UnwrapAllJoynServiceInfo(info[0]);
          
          op = wrapper->_instance->GetAboutDataAsync(arg0);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynServiceInfo^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Globalization::Language^>(info[1]))
      {
        try
        {
          ::Windows::Devices::AllJoyn::AllJoynServiceInfo^ arg0 = UnwrapAllJoynServiceInfo(info[0]);
          ::Windows::Globalization::Language^ arg1 = dynamic_cast<::Windows::Globalization::Language^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          op = wrapper->_instance->GetAboutDataAsync(arg0,arg1);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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

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

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

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

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

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Devices::AllJoyn::AllJoynBusAttachment^ result;
          result = ::Windows::Devices::AllJoyn::AllJoynBusAttachment::GetDefault();
          info.GetReturnValue().Set(WrapAllJoynBusAttachment(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 GetWatcher(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Platform::String^>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<::Platform::String^>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Platform::String^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Platform::String^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return (!NodeRT::Utils::IsWinRtWrapper(value));
                 },
                 [](Local<Value> value) -> ::Platform::String^ {
                   return ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Platform::String^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          ::Windows::Devices::Enumeration::DeviceWatcher^ result;
          result = ::Windows::Devices::AllJoyn::AllJoynBusAttachment::GetWatcher(arg0);
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Devices.Enumeration", "DeviceWatcher", 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 AboutDataGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::Devices::AllJoyn::AllJoynAuthenticationMechanism>^ result = wrapper->_instance->AuthenticationMechanisms;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Devices::AllJoyn::AllJoynAuthenticationMechanism>::CreateVectorWrapper(result, 
            [](::Windows::Devices::AllJoyn::AllJoynAuthenticationMechanism val) -> Local<Value> {
              return Nan::New<Integer>(static_cast<int>(val));
            },
            [](Local<Value> value) -> bool {
              return value->IsInt32();
            },
            [](Local<Value> value) -> ::Windows::Devices::AllJoyn::AllJoynAuthenticationMechanism {
              return static_cast<::Windows::Devices::AllJoyn::AllJoynAuthenticationMechanism>(Nan::To<int32_t>(value).FromMaybe(0));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ConnectionSpecificationGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

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

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

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

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


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

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

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

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

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"authenticationComplete", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynBusAttachment^>(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;
        }
        AllJoynBusAttachment *wrapper = AllJoynBusAttachment::Unwrap<AllJoynBusAttachment>(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->AuthenticationComplete::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::AllJoyn::AllJoynBusAttachment^, ::Windows::Devices::AllJoyn::AllJoynAuthenticationCompleteEventArgs^>(
            [callbackObjPtr](::Windows::Devices::AllJoyn::AllJoynBusAttachment^ arg0, ::Windows::Devices::AllJoyn::AllJoynAuthenticationCompleteEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAllJoynBusAttachment(arg0);
                  wrappedArg1 = WrapAllJoynAuthenticationCompleteEventArgs(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"credentialsRequested", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynBusAttachment^>(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;
        }
        AllJoynBusAttachment *wrapper = AllJoynBusAttachment::Unwrap<AllJoynBusAttachment>(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->CredentialsRequested::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::AllJoyn::AllJoynBusAttachment^, ::Windows::Devices::AllJoyn::AllJoynCredentialsRequestedEventArgs^>(
            [callbackObjPtr](::Windows::Devices::AllJoyn::AllJoynBusAttachment^ arg0, ::Windows::Devices::AllJoyn::AllJoynCredentialsRequestedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAllJoynBusAttachment(arg0);
                  wrappedArg1 = WrapAllJoynCredentialsRequestedEventArgs(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"credentialsVerificationRequested", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynBusAttachment^>(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;
        }
        AllJoynBusAttachment *wrapper = AllJoynBusAttachment::Unwrap<AllJoynBusAttachment>(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->CredentialsVerificationRequested::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::AllJoyn::AllJoynBusAttachment^, ::Windows::Devices::AllJoyn::AllJoynCredentialsVerificationRequestedEventArgs^>(
            [callbackObjPtr](::Windows::Devices::AllJoyn::AllJoynBusAttachment^ arg0, ::Windows::Devices::AllJoyn::AllJoynCredentialsVerificationRequestedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAllJoynBusAttachment(arg0);
                  wrappedArg1 = WrapAllJoynCredentialsVerificationRequestedEventArgs(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"stateChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynBusAttachment^>(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;
        }
        AllJoynBusAttachment *wrapper = AllJoynBusAttachment::Unwrap<AllJoynBusAttachment>(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->StateChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::AllJoyn::AllJoynBusAttachment^, ::Windows::Devices::AllJoyn::AllJoynBusAttachmentStateChangedEventArgs^>(
            [callbackObjPtr](::Windows::Devices::AllJoyn::AllJoynBusAttachment^ arg0, ::Windows::Devices::AllJoyn::AllJoynBusAttachmentStateChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAllJoynBusAttachment(arg0);
                  wrappedArg1 = WrapAllJoynBusAttachmentStateChangedEventArgs(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"acceptSessionJoinerRequested", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynBusAttachment^>(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;
        }
        AllJoynBusAttachment *wrapper = AllJoynBusAttachment::Unwrap<AllJoynBusAttachment>(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->AcceptSessionJoinerRequested::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::AllJoyn::AllJoynBusAttachment^, ::Windows::Devices::AllJoyn::AllJoynAcceptSessionJoinerEventArgs^>(
            [callbackObjPtr](::Windows::Devices::AllJoyn::AllJoynBusAttachment^ arg0, ::Windows::Devices::AllJoyn::AllJoynAcceptSessionJoinerEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAllJoynBusAttachment(arg0);
                  wrappedArg1 = WrapAllJoynAcceptSessionJoinerEventArgs(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"sessionJoined", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynBusAttachment^>(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;
        }
        AllJoynBusAttachment *wrapper = AllJoynBusAttachment::Unwrap<AllJoynBusAttachment>(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->SessionJoined::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::AllJoyn::AllJoynBusAttachment^, ::Windows::Devices::AllJoyn::AllJoynSessionJoinedEventArgs^>(
            [callbackObjPtr](::Windows::Devices::AllJoyn::AllJoynBusAttachment^ arg0, ::Windows::Devices::AllJoyn::AllJoynSessionJoinedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAllJoynBusAttachment(arg0);
                  wrappedArg1 = WrapAllJoynSessionJoinedEventArgs(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"authenticationComplete", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"credentialsRequested", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"credentialsVerificationRequested", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"stateChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"acceptSessionJoinerRequested", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"sessionJoined", 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"authenticationComplete", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynBusAttachment^>(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;
          }
          AllJoynBusAttachment *wrapper = AllJoynBusAttachment::Unwrap<AllJoynBusAttachment>(info.This());
          wrapper->_instance->AuthenticationComplete::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"credentialsRequested", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynBusAttachment^>(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;
          }
          AllJoynBusAttachment *wrapper = AllJoynBusAttachment::Unwrap<AllJoynBusAttachment>(info.This());
          wrapper->_instance->CredentialsRequested::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"credentialsVerificationRequested", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynBusAttachment^>(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;
          }
          AllJoynBusAttachment *wrapper = AllJoynBusAttachment::Unwrap<AllJoynBusAttachment>(info.This());
          wrapper->_instance->CredentialsVerificationRequested::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"stateChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynBusAttachment^>(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;
          }
          AllJoynBusAttachment *wrapper = AllJoynBusAttachment::Unwrap<AllJoynBusAttachment>(info.This());
          wrapper->_instance->StateChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"acceptSessionJoinerRequested", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynBusAttachment^>(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;
          }
          AllJoynBusAttachment *wrapper = AllJoynBusAttachment::Unwrap<AllJoynBusAttachment>(info.This());
          wrapper->_instance->AcceptSessionJoinerRequested::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"sessionJoined", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynBusAttachment^>(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;
          }
          AllJoynBusAttachment *wrapper = AllJoynBusAttachment::Unwrap<AllJoynBusAttachment>(info.This());
          wrapper->_instance->SessionJoined::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

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

      friend v8::Local<v8::Value> WrapAllJoynBusAttachment(::Windows::Devices::AllJoyn::AllJoynBusAttachment^ wintRtInstance);
      friend ::Windows::Devices::AllJoyn::AllJoynBusAttachment^ UnwrapAllJoynBusAttachment(Local<Value> value);
  };

  Persistent<FunctionTemplate> AllJoynBusAttachment::s_constructorTemplate;

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

  ::Windows::Devices::AllJoyn::AllJoynBusAttachment^ UnwrapAllJoynBusAttachment(Local<Value> value) {
     return AllJoynBusAttachment::Unwrap<AllJoynBusAttachment>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAllJoynBusAttachment(Local<Object> exports) {
    AllJoynBusAttachment::Init(exports);
  }

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





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

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

    private:

      AllJoynBusAttachmentStateChangedEventArgs(::Windows::Devices::AllJoyn::AllJoynBusAttachmentStateChangedEventArgs^ instance) {
        _instance = instance;
      }

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

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::Devices::AllJoyn::AllJoynBusAttachmentStateChangedEventArgs^ winRtInstance;


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

      AllJoynBusAttachmentStateChangedEventArgs *wrapperInstance = new AllJoynBusAttachmentStateChangedEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynBusAttachmentStateChangedEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::Devices::AllJoyn::AllJoynBusAttachmentStateChangedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Devices::AllJoyn::AllJoynBusAttachmentStateChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

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

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

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

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


    private:
      ::Windows::Devices::AllJoyn::AllJoynBusAttachmentStateChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAllJoynBusAttachmentStateChangedEventArgs(::Windows::Devices::AllJoyn::AllJoynBusAttachmentStateChangedEventArgs^ wintRtInstance);
      friend ::Windows::Devices::AllJoyn::AllJoynBusAttachmentStateChangedEventArgs^ UnwrapAllJoynBusAttachmentStateChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> AllJoynBusAttachmentStateChangedEventArgs::s_constructorTemplate;

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

  ::Windows::Devices::AllJoyn::AllJoynBusAttachmentStateChangedEventArgs^ UnwrapAllJoynBusAttachmentStateChangedEventArgs(Local<Value> value) {
     return AllJoynBusAttachmentStateChangedEventArgs::Unwrap<AllJoynBusAttachmentStateChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAllJoynBusAttachmentStateChangedEventArgs(Local<Object> exports) {
    AllJoynBusAttachmentStateChangedEventArgs::Init(exports);
  }

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


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



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("attemptCount").ToLocalChecked(), AttemptCountGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("credentials").ToLocalChecked(), CredentialsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("peerUniqueName").ToLocalChecked(), PeerUniqueNameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("requestedUserName").ToLocalChecked(), RequestedUserNameGetter);

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



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

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

    private:

      AllJoynCredentialsRequestedEventArgs(::Windows::Devices::AllJoyn::AllJoynCredentialsRequestedEventArgs^ instance) {
        _instance = instance;
      }

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

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::Devices::AllJoyn::AllJoynCredentialsRequestedEventArgs^ winRtInstance;


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

      AllJoynCredentialsRequestedEventArgs *wrapperInstance = new AllJoynCredentialsRequestedEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynCredentialsRequestedEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::Devices::AllJoyn::AllJoynCredentialsRequestedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Devices::AllJoyn::AllJoynCredentialsRequestedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


    private:
      ::Windows::Devices::AllJoyn::AllJoynCredentialsRequestedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAllJoynCredentialsRequestedEventArgs(::Windows::Devices::AllJoyn::AllJoynCredentialsRequestedEventArgs^ wintRtInstance);
      friend ::Windows::Devices::AllJoyn::AllJoynCredentialsRequestedEventArgs^ UnwrapAllJoynCredentialsRequestedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> AllJoynCredentialsRequestedEventArgs::s_constructorTemplate;

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

  ::Windows::Devices::AllJoyn::AllJoynCredentialsRequestedEventArgs^ UnwrapAllJoynCredentialsRequestedEventArgs(Local<Value> value) {
     return AllJoynCredentialsRequestedEventArgs::Unwrap<AllJoynCredentialsRequestedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAllJoynCredentialsRequestedEventArgs(Local<Object> exports) {
    AllJoynCredentialsRequestedEventArgs::Init(exports);
  }

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


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



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("authenticationMechanism").ToLocalChecked(), AuthenticationMechanismGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("peerCertificate").ToLocalChecked(), PeerCertificateGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("peerCertificateErrorSeverity").ToLocalChecked(), PeerCertificateErrorSeverityGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("peerCertificateErrors").ToLocalChecked(), PeerCertificateErrorsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("peerIntermediateCertificates").ToLocalChecked(), PeerIntermediateCertificatesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("peerUniqueName").ToLocalChecked(), PeerUniqueNameGetter);

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



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

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

    private:

      AllJoynCredentialsVerificationRequestedEventArgs(::Windows::Devices::AllJoyn::AllJoynCredentialsVerificationRequestedEventArgs^ instance) {
        _instance = instance;
      }

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

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::Devices::AllJoyn::AllJoynCredentialsVerificationRequestedEventArgs^ winRtInstance;


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

      AllJoynCredentialsVerificationRequestedEventArgs *wrapperInstance = new AllJoynCredentialsVerificationRequestedEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynCredentialsVerificationRequestedEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::Devices::AllJoyn::AllJoynCredentialsVerificationRequestedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Devices::AllJoyn::AllJoynCredentialsVerificationRequestedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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


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

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

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

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->Accept();
          return;
        } catch (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 GetDeferral(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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

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

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

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

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

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

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

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

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Security::Cryptography::Certificates::ChainValidationResult>^ result = wrapper->_instance->PeerCertificateErrors;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Security::Cryptography::Certificates::ChainValidationResult>::CreateVectorViewWrapper(result, 
            [](::Windows::Security::Cryptography::Certificates::ChainValidationResult val) -> Local<Value> {
              return Nan::New<Integer>(static_cast<int>(val));
            },
            [](Local<Value> value) -> bool {
              return value->IsInt32();
            },
            [](Local<Value> value) -> ::Windows::Security::Cryptography::Certificates::ChainValidationResult {
              return static_cast<::Windows::Security::Cryptography::Certificates::ChainValidationResult>(Nan::To<int32_t>(value).FromMaybe(0));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PeerIntermediateCertificatesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Security::Cryptography::Certificates::Certificate^>^ result = wrapper->_instance->PeerIntermediateCertificates;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Security::Cryptography::Certificates::Certificate^>::CreateVectorViewWrapper(result, 
            [](::Windows::Security::Cryptography::Certificates::Certificate^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.Security.Cryptography.Certificates", "Certificate", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Security::Cryptography::Certificates::Certificate^>(value);
            },
            [](Local<Value> value) -> ::Windows::Security::Cryptography::Certificates::Certificate^ {
              return dynamic_cast<::Windows::Security::Cryptography::Certificates::Certificate^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PeerUniqueNameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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


    private:
      ::Windows::Devices::AllJoyn::AllJoynCredentialsVerificationRequestedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAllJoynCredentialsVerificationRequestedEventArgs(::Windows::Devices::AllJoyn::AllJoynCredentialsVerificationRequestedEventArgs^ wintRtInstance);
      friend ::Windows::Devices::AllJoyn::AllJoynCredentialsVerificationRequestedEventArgs^ UnwrapAllJoynCredentialsVerificationRequestedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> AllJoynCredentialsVerificationRequestedEventArgs::s_constructorTemplate;

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

  ::Windows::Devices::AllJoyn::AllJoynCredentialsVerificationRequestedEventArgs^ UnwrapAllJoynCredentialsVerificationRequestedEventArgs(Local<Value> value) {
     return AllJoynCredentialsVerificationRequestedEventArgs::Unwrap<AllJoynCredentialsVerificationRequestedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAllJoynCredentialsVerificationRequestedEventArgs(Local<Object> exports) {
    AllJoynCredentialsVerificationRequestedEventArgs::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("authenticationMechanism").ToLocalChecked(), AuthenticationMechanismGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("peerUniqueName").ToLocalChecked(), PeerUniqueNameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("succeeded").ToLocalChecked(), SucceededGetter);

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



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

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

    private:

      AllJoynAuthenticationCompleteEventArgs(::Windows::Devices::AllJoyn::AllJoynAuthenticationCompleteEventArgs^ instance) {
        _instance = instance;
      }

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

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::Devices::AllJoyn::AllJoynAuthenticationCompleteEventArgs^ winRtInstance;


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

      AllJoynAuthenticationCompleteEventArgs *wrapperInstance = new AllJoynAuthenticationCompleteEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynAuthenticationCompleteEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::Devices::AllJoyn::AllJoynAuthenticationCompleteEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Devices::AllJoyn::AllJoynAuthenticationCompleteEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

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

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

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

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

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

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

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


    private:
      ::Windows::Devices::AllJoyn::AllJoynAuthenticationCompleteEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAllJoynAuthenticationCompleteEventArgs(::Windows::Devices::AllJoyn::AllJoynAuthenticationCompleteEventArgs^ wintRtInstance);
      friend ::Windows::Devices::AllJoyn::AllJoynAuthenticationCompleteEventArgs^ UnwrapAllJoynAuthenticationCompleteEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> AllJoynAuthenticationCompleteEventArgs::s_constructorTemplate;

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

  ::Windows::Devices::AllJoyn::AllJoynAuthenticationCompleteEventArgs^ UnwrapAllJoynAuthenticationCompleteEventArgs(Local<Value> value) {
     return AllJoynAuthenticationCompleteEventArgs::Unwrap<AllJoynAuthenticationCompleteEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAllJoynAuthenticationCompleteEventArgs(Local<Object> exports) {
    AllJoynAuthenticationCompleteEventArgs::Init(exports);
  }

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

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




          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("objectPath").ToLocalChecked(), ObjectPathGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("sessionPort").ToLocalChecked(), SessionPortGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("uniqueName").ToLocalChecked(), UniqueNameGetter);

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

        func = Nan::GetFunction(Nan::New<FunctionTemplate>(FromIdAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("fromIdAsync").ToLocalChecked(), func);


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

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

    private:

      AllJoynServiceInfo(::Windows::Devices::AllJoyn::AllJoynServiceInfo^ instance) {
        _instance = instance;
      }

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

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::Devices::AllJoyn::AllJoynServiceInfo^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynServiceInfo^>(info[0])) {
        try {
          winRtInstance = (::Windows::Devices::AllJoyn::AllJoynServiceInfo^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && info[0]->IsString()
        && info[1]->IsString()
        && info[2]->IsInt32())
      {
        try {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          unsigned short arg2 = static_cast<unsigned short>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          
          winRtInstance = ref new ::Windows::Devices::AllJoyn::AllJoynServiceInfo(arg0,arg1,arg2);
        } 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());

      AllJoynServiceInfo *wrapperInstance = new AllJoynServiceInfo(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynServiceInfo^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::Devices::AllJoyn::AllJoynServiceInfo^ winRtInstance;
      try {
        winRtInstance = (::Windows::Devices::AllJoyn::AllJoynServiceInfo^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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




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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Devices::AllJoyn::AllJoynServiceInfo^>^ op;


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

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

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


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapAllJoynServiceInfo(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 ObjectPathGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

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

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

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

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


    private:
      ::Windows::Devices::AllJoyn::AllJoynServiceInfo^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAllJoynServiceInfo(::Windows::Devices::AllJoyn::AllJoynServiceInfo^ wintRtInstance);
      friend ::Windows::Devices::AllJoyn::AllJoynServiceInfo^ UnwrapAllJoynServiceInfo(Local<Value> value);
  };

  Persistent<FunctionTemplate> AllJoynServiceInfo::s_constructorTemplate;

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

  ::Windows::Devices::AllJoyn::AllJoynServiceInfo^ UnwrapAllJoynServiceInfo(Local<Value> value) {
     return AllJoynServiceInfo::Unwrap<AllJoynServiceInfo>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAllJoynServiceInfo(Local<Object> exports) {
    AllJoynServiceInfo::Init(exports);
  }

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

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




          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("aJSoftwareVersion").ToLocalChecked(), AJSoftwareVersionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("appId").ToLocalChecked(), AppIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("appName").ToLocalChecked(), AppNameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dateOfManufacture").ToLocalChecked(), DateOfManufactureGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("defaultLanguage").ToLocalChecked(), DefaultLanguageGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("description").ToLocalChecked(), DescriptionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("deviceId").ToLocalChecked(), DeviceIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("deviceName").ToLocalChecked(), DeviceNameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("hardwareVersion").ToLocalChecked(), HardwareVersionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("manufacturer").ToLocalChecked(), ManufacturerGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("modelNumber").ToLocalChecked(), ModelNumberGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("properties").ToLocalChecked(), PropertiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("softwareVersion").ToLocalChecked(), SoftwareVersionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("status").ToLocalChecked(), StatusGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("supportUrl").ToLocalChecked(), SupportUrlGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("supportedLanguages").ToLocalChecked(), SupportedLanguagesGetter);

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

        func = Nan::GetFunction(Nan::New<FunctionTemplate>(GetDataBySessionPortAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("getDataBySessionPortAsync").ToLocalChecked(), func);


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

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

    private:

      AllJoynAboutDataView(::Windows::Devices::AllJoyn::AllJoynAboutDataView^ instance) {
        _instance = instance;
      }

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

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::Devices::AllJoyn::AllJoynAboutDataView^ winRtInstance;


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

      AllJoynAboutDataView *wrapperInstance = new AllJoynAboutDataView(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynAboutDataView^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::Devices::AllJoyn::AllJoynAboutDataView^ winRtInstance;
      try {
        winRtInstance = (::Windows::Devices::AllJoyn::AllJoynAboutDataView^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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




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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Devices::AllJoyn::AllJoynAboutDataView^>^ op;


      if (info.Length() == 4
          && info[0]->IsString()
          && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynBusAttachment^>(info[1])
          && info[2]->IsInt32())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Devices::AllJoyn::AllJoynBusAttachment^ arg1 = UnwrapAllJoynBusAttachment(info[1]);
          unsigned short arg2 = static_cast<unsigned short>(Nan::To<int32_t>(info[2]).FromMaybe(0));
            
          op = ::Windows::Devices::AllJoyn::AllJoynAboutDataView::GetDataBySessionPortAsync(arg0,arg1,arg2);
        } catch (Platform::Exception ^exception) {
            NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
            return;
        }
      }
      else if (info.Length() == 5
          && info[0]->IsString()
          && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynBusAttachment^>(info[1])
          && info[2]->IsInt32()
          && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Globalization::Language^>(info[3]))
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Devices::AllJoyn::AllJoynBusAttachment^ arg1 = UnwrapAllJoynBusAttachment(info[1]);
          unsigned short arg2 = static_cast<unsigned short>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          ::Windows::Globalization::Language^ arg3 = dynamic_cast<::Windows::Globalization::Language^>(NodeRT::Utils::GetObjectInstance(info[3]));
            
          op = ::Windows::Devices::AllJoyn::AllJoynAboutDataView::GetDataBySessionPortAsync(arg0,arg1,arg2,arg3);
        } catch (Platform::Exception ^exception) {
            NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
            return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapAllJoynAboutDataView(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 AJSoftwareVersionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try  {
        ::Windows::Foundation::Collections::IMapView<::Platform::String^, ::Platform::Object^>^ result = wrapper->_instance->Properties;
        info.GetReturnValue().Set(NodeRT::Collections::MapViewWrapper<::Platform::String^,::Platform::Object^>::CreateMapViewWrapper(result, 
            [](::Platform::String^ val) -> Local<Value> {
              return NodeRT::Utils::NewString(val->Data());
            },
            [](Local<Value> value) -> bool {
              return value->IsString();
            },
            [](Local<Value> value) -> ::Platform::String^ {
              return ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));
            },
            [](::Platform::Object^ val) -> Local<Value> {
              return CreateOpaqueWrapper(val);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SoftwareVersionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

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

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

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

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Globalization::Language^>^ result = wrapper->_instance->SupportedLanguages;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Globalization::Language^>::CreateVectorViewWrapper(result, 
            [](::Windows::Globalization::Language^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.Globalization", "Language", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Globalization::Language^>(value);
            },
            [](Local<Value> value) -> ::Windows::Globalization::Language^ {
              return dynamic_cast<::Windows::Globalization::Language^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Devices::AllJoyn::AllJoynAboutDataView^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAllJoynAboutDataView(::Windows::Devices::AllJoyn::AllJoynAboutDataView^ wintRtInstance);
      friend ::Windows::Devices::AllJoyn::AllJoynAboutDataView^ UnwrapAllJoynAboutDataView(Local<Value> value);
  };

  Persistent<FunctionTemplate> AllJoynAboutDataView::s_constructorTemplate;

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

  ::Windows::Devices::AllJoyn::AllJoynAboutDataView^ UnwrapAllJoynAboutDataView(Local<Value> value) {
     return AllJoynAboutDataView::Unwrap<AllJoynAboutDataView>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAllJoynAboutDataView(Local<Object> exports) {
    AllJoynAboutDataView::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "accept", Accept);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("sameNetwork").ToLocalChecked(), SameNetworkGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("samePhysicalNode").ToLocalChecked(), SamePhysicalNodeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("sessionPort").ToLocalChecked(), SessionPortGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("trafficType").ToLocalChecked(), TrafficTypeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("uniqueName").ToLocalChecked(), UniqueNameGetter);

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



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

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

    private:

      AllJoynAcceptSessionJoinerEventArgs(::Windows::Devices::AllJoyn::AllJoynAcceptSessionJoinerEventArgs^ instance) {
        _instance = instance;
      }

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

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::Devices::AllJoyn::AllJoynAcceptSessionJoinerEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynAcceptSessionJoinerEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::Devices::AllJoyn::AllJoynAcceptSessionJoinerEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 5
        && info[0]->IsString()
        && info[1]->IsInt32()
        && info[2]->IsInt32()
        && info[3]->IsInt32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::IAllJoynAcceptSessionJoiner^>(info[4]))
      {
        try {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          unsigned short arg1 = static_cast<unsigned short>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          ::Windows::Devices::AllJoyn::AllJoynTrafficType arg2 = static_cast<::Windows::Devices::AllJoyn::AllJoynTrafficType>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          unsigned char arg3 = static_cast<unsigned char>(Nan::To<int32_t>(info[3]).FromMaybe(0));
          ::Windows::Devices::AllJoyn::IAllJoynAcceptSessionJoiner^ arg4 = UnwrapIAllJoynAcceptSessionJoiner(info[4]);
          
          winRtInstance = ref new ::Windows::Devices::AllJoyn::AllJoynAcceptSessionJoinerEventArgs(arg0,arg1,arg2,arg3,arg4);
        } 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());

      AllJoynAcceptSessionJoinerEventArgs *wrapperInstance = new AllJoynAcceptSessionJoinerEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynAcceptSessionJoinerEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::Devices::AllJoyn::AllJoynAcceptSessionJoinerEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Devices::AllJoyn::AllJoynAcceptSessionJoinerEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


    private:
      ::Windows::Devices::AllJoyn::AllJoynAcceptSessionJoinerEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAllJoynAcceptSessionJoinerEventArgs(::Windows::Devices::AllJoyn::AllJoynAcceptSessionJoinerEventArgs^ wintRtInstance);
      friend ::Windows::Devices::AllJoyn::AllJoynAcceptSessionJoinerEventArgs^ UnwrapAllJoynAcceptSessionJoinerEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> AllJoynAcceptSessionJoinerEventArgs::s_constructorTemplate;

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

  ::Windows::Devices::AllJoyn::AllJoynAcceptSessionJoinerEventArgs^ UnwrapAllJoynAcceptSessionJoinerEventArgs(Local<Value> value) {
     return AllJoynAcceptSessionJoinerEventArgs::Unwrap<AllJoynAcceptSessionJoinerEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAllJoynAcceptSessionJoinerEventArgs(Local<Object> exports) {
    AllJoynAcceptSessionJoinerEventArgs::Init(exports);
  }

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





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

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



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

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

    private:

      AllJoynSessionJoinedEventArgs(::Windows::Devices::AllJoyn::AllJoynSessionJoinedEventArgs^ instance) {
        _instance = instance;
      }

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

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::Devices::AllJoyn::AllJoynSessionJoinedEventArgs^ winRtInstance;


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

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

      AllJoynSessionJoinedEventArgs *wrapperInstance = new AllJoynSessionJoinedEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynSessionJoinedEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::Devices::AllJoyn::AllJoynSessionJoinedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Devices::AllJoyn::AllJoynSessionJoinedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

      try  {
        ::Windows::Devices::AllJoyn::AllJoynSession^ result = wrapper->_instance->Session;
        info.GetReturnValue().Set(WrapAllJoynSession(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Devices::AllJoyn::AllJoynSessionJoinedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAllJoynSessionJoinedEventArgs(::Windows::Devices::AllJoyn::AllJoynSessionJoinedEventArgs^ wintRtInstance);
      friend ::Windows::Devices::AllJoyn::AllJoynSessionJoinedEventArgs^ UnwrapAllJoynSessionJoinedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> AllJoynSessionJoinedEventArgs::s_constructorTemplate;

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

  ::Windows::Devices::AllJoyn::AllJoynSessionJoinedEventArgs^ UnwrapAllJoynSessionJoinedEventArgs(Local<Value> value) {
     return AllJoynSessionJoinedEventArgs::Unwrap<AllJoynSessionJoinedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAllJoynSessionJoinedEventArgs(Local<Object> exports) {
    AllJoynSessionJoinedEventArgs::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("timeout").ToLocalChecked(), TimeoutGetter, TimeoutSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("passwordCredential").ToLocalChecked(), PasswordCredentialGetter, PasswordCredentialSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("certificate").ToLocalChecked(), CertificateGetter, CertificateSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("authenticationMechanism").ToLocalChecked(), AuthenticationMechanismGetter);

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



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

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

    private:

      AllJoynCredentials(::Windows::Devices::AllJoyn::AllJoynCredentials^ instance) {
        _instance = instance;
      }

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

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::Devices::AllJoyn::AllJoynCredentials^ winRtInstance;


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

      AllJoynCredentials *wrapperInstance = new AllJoynCredentials(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynCredentials^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::Devices::AllJoyn::AllJoynCredentials^ winRtInstance;
      try {
        winRtInstance = (::Windows::Devices::AllJoyn::AllJoynCredentials^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

      try  {
        ::Windows::Foundation::TimeSpan result = wrapper->_instance->Timeout;
        info.GetReturnValue().Set(Nan::New<Number>(result.Duration/10000.0));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TimeoutSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

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

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

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

      try {

        ::Windows::Foundation::TimeSpan winRtValue = NodeRT::Utils::TimeSpanFromMilli(Nan::To<int64_t>(value).FromMaybe(0));

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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Security::Credentials::PasswordCredential^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

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

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

      try {

        ::Windows::Security::Credentials::PasswordCredential^ winRtValue = dynamic_cast<::Windows::Security::Credentials::PasswordCredential^>(NodeRT::Utils::GetObjectInstance(value));

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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Security::Cryptography::Certificates::Certificate^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

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

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

      try {

        ::Windows::Security::Cryptography::Certificates::Certificate^ winRtValue = dynamic_cast<::Windows::Security::Cryptography::Certificates::Certificate^>(NodeRT::Utils::GetObjectInstance(value));

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

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

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

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


    private:
      ::Windows::Devices::AllJoyn::AllJoynCredentials^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAllJoynCredentials(::Windows::Devices::AllJoyn::AllJoynCredentials^ wintRtInstance);
      friend ::Windows::Devices::AllJoyn::AllJoynCredentials^ UnwrapAllJoynCredentials(Local<Value> value);
  };

  Persistent<FunctionTemplate> AllJoynCredentials::s_constructorTemplate;

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

  ::Windows::Devices::AllJoyn::AllJoynCredentials^ UnwrapAllJoynCredentials(Local<Value> value) {
     return AllJoynCredentials::Unwrap<AllJoynCredentials>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAllJoynCredentials(Local<Object> exports) {
    AllJoynCredentials::Init(exports);
  }

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

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


          
            Nan::SetPrototypeMethod(localRef, "removeMemberAsync", RemoveMemberAsync);
          

          
          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>("id").ToLocalChecked(), IdGetter);
            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);

        func = Nan::GetFunction(Nan::New<FunctionTemplate>(GetFromServiceInfoAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("getFromServiceInfoAsync").ToLocalChecked(), func);


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

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

    private:

      AllJoynSession(::Windows::Devices::AllJoyn::AllJoynSession^ instance) {
        _instance = instance;
      }

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

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::Devices::AllJoyn::AllJoynSession^ winRtInstance;


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

      AllJoynSession *wrapperInstance = new AllJoynSession(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynSession^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::Devices::AllJoyn::AllJoynSession^ winRtInstance;
      try {
        winRtInstance = (::Windows::Devices::AllJoyn::AllJoynSession^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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

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

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

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

      ::Windows::Foundation::IAsyncOperation<int>^ op;


      if (info.Length() == 2
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          op = wrapper->_instance->RemoveMemberAsync(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<int> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Devices::AllJoyn::AllJoynSession^>^ op;


      if (info.Length() == 2
          && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynServiceInfo^>(info[0]))
      {
        try
        {
          ::Windows::Devices::AllJoyn::AllJoynServiceInfo^ arg0 = UnwrapAllJoynServiceInfo(info[0]);
            
          op = ::Windows::Devices::AllJoyn::AllJoynSession::GetFromServiceInfoAsync(arg0);
        } catch (Platform::Exception ^exception) {
            NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
            return;
        }
      }
      else if (info.Length() == 3
          && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynServiceInfo^>(info[0])
          && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynBusAttachment^>(info[1]))
      {
        try
        {
          ::Windows::Devices::AllJoyn::AllJoynServiceInfo^ arg0 = UnwrapAllJoynServiceInfo(info[0]);
          ::Windows::Devices::AllJoyn::AllJoynBusAttachment^ arg1 = UnwrapAllJoynBusAttachment(info[1]);
            
          op = ::Windows::Devices::AllJoyn::AllJoynSession::GetFromServiceInfoAsync(arg0,arg1);
        } catch (Platform::Exception ^exception) {
            NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
            return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapAllJoynSession(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 IdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

      try  {
        int result = wrapper->_instance->Status;
        info.GetReturnValue().Set(Nan::New<Integer>(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"lost", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynSession^>(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;
        }
        AllJoynSession *wrapper = AllJoynSession::Unwrap<AllJoynSession>(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->Lost::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::AllJoyn::AllJoynSession^, ::Windows::Devices::AllJoyn::AllJoynSessionLostEventArgs^>(
            [callbackObjPtr](::Windows::Devices::AllJoyn::AllJoynSession^ arg0, ::Windows::Devices::AllJoyn::AllJoynSessionLostEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAllJoynSession(arg0);
                  wrappedArg1 = WrapAllJoynSessionLostEventArgs(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"memberAdded", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynSession^>(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;
        }
        AllJoynSession *wrapper = AllJoynSession::Unwrap<AllJoynSession>(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->MemberAdded::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::AllJoyn::AllJoynSession^, ::Windows::Devices::AllJoyn::AllJoynSessionMemberAddedEventArgs^>(
            [callbackObjPtr](::Windows::Devices::AllJoyn::AllJoynSession^ arg0, ::Windows::Devices::AllJoyn::AllJoynSessionMemberAddedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAllJoynSession(arg0);
                  wrappedArg1 = WrapAllJoynSessionMemberAddedEventArgs(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"memberRemoved", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynSession^>(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;
        }
        AllJoynSession *wrapper = AllJoynSession::Unwrap<AllJoynSession>(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->MemberRemoved::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Devices::AllJoyn::AllJoynSession^, ::Windows::Devices::AllJoyn::AllJoynSessionMemberRemovedEventArgs^>(
            [callbackObjPtr](::Windows::Devices::AllJoyn::AllJoynSession^ arg0, ::Windows::Devices::AllJoyn::AllJoynSessionMemberRemovedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAllJoynSession(arg0);
                  wrappedArg1 = WrapAllJoynSessionMemberRemovedEventArgs(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"lost", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"memberAdded", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"memberRemoved", 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"lost", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynSession^>(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;
          }
          AllJoynSession *wrapper = AllJoynSession::Unwrap<AllJoynSession>(info.This());
          wrapper->_instance->Lost::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"memberAdded", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynSession^>(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;
          }
          AllJoynSession *wrapper = AllJoynSession::Unwrap<AllJoynSession>(info.This());
          wrapper->_instance->MemberAdded::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"memberRemoved", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynSession^>(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;
          }
          AllJoynSession *wrapper = AllJoynSession::Unwrap<AllJoynSession>(info.This());
          wrapper->_instance->MemberRemoved::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

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

      friend v8::Local<v8::Value> WrapAllJoynSession(::Windows::Devices::AllJoyn::AllJoynSession^ wintRtInstance);
      friend ::Windows::Devices::AllJoyn::AllJoynSession^ UnwrapAllJoynSession(Local<Value> value);
  };

  Persistent<FunctionTemplate> AllJoynSession::s_constructorTemplate;

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

  ::Windows::Devices::AllJoyn::AllJoynSession^ UnwrapAllJoynSession(Local<Value> value) {
     return AllJoynSession::Unwrap<AllJoynSession>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAllJoynSession(Local<Object> exports) {
    AllJoynSession::Init(exports);
  }

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





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

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



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

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

    private:

      AllJoynSessionMemberAddedEventArgs(::Windows::Devices::AllJoyn::AllJoynSessionMemberAddedEventArgs^ instance) {
        _instance = instance;
      }

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

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::Devices::AllJoyn::AllJoynSessionMemberAddedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynSessionMemberAddedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::Devices::AllJoyn::AllJoynSessionMemberAddedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && info[0]->IsString())
      {
        try {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          winRtInstance = ref new ::Windows::Devices::AllJoyn::AllJoynSessionMemberAddedEventArgs(arg0);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

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

      AllJoynSessionMemberAddedEventArgs *wrapperInstance = new AllJoynSessionMemberAddedEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynSessionMemberAddedEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::Devices::AllJoyn::AllJoynSessionMemberAddedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Devices::AllJoyn::AllJoynSessionMemberAddedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

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


    private:
      ::Windows::Devices::AllJoyn::AllJoynSessionMemberAddedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAllJoynSessionMemberAddedEventArgs(::Windows::Devices::AllJoyn::AllJoynSessionMemberAddedEventArgs^ wintRtInstance);
      friend ::Windows::Devices::AllJoyn::AllJoynSessionMemberAddedEventArgs^ UnwrapAllJoynSessionMemberAddedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> AllJoynSessionMemberAddedEventArgs::s_constructorTemplate;

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

  ::Windows::Devices::AllJoyn::AllJoynSessionMemberAddedEventArgs^ UnwrapAllJoynSessionMemberAddedEventArgs(Local<Value> value) {
     return AllJoynSessionMemberAddedEventArgs::Unwrap<AllJoynSessionMemberAddedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAllJoynSessionMemberAddedEventArgs(Local<Object> exports) {
    AllJoynSessionMemberAddedEventArgs::Init(exports);
  }

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





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

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



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

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

    private:

      AllJoynSessionMemberRemovedEventArgs(::Windows::Devices::AllJoyn::AllJoynSessionMemberRemovedEventArgs^ instance) {
        _instance = instance;
      }

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

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::Devices::AllJoyn::AllJoynSessionMemberRemovedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynSessionMemberRemovedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::Devices::AllJoyn::AllJoynSessionMemberRemovedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && info[0]->IsString())
      {
        try {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          winRtInstance = ref new ::Windows::Devices::AllJoyn::AllJoynSessionMemberRemovedEventArgs(arg0);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

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

      AllJoynSessionMemberRemovedEventArgs *wrapperInstance = new AllJoynSessionMemberRemovedEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynSessionMemberRemovedEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::Devices::AllJoyn::AllJoynSessionMemberRemovedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Devices::AllJoyn::AllJoynSessionMemberRemovedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

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


    private:
      ::Windows::Devices::AllJoyn::AllJoynSessionMemberRemovedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAllJoynSessionMemberRemovedEventArgs(::Windows::Devices::AllJoyn::AllJoynSessionMemberRemovedEventArgs^ wintRtInstance);
      friend ::Windows::Devices::AllJoyn::AllJoynSessionMemberRemovedEventArgs^ UnwrapAllJoynSessionMemberRemovedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> AllJoynSessionMemberRemovedEventArgs::s_constructorTemplate;

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

  ::Windows::Devices::AllJoyn::AllJoynSessionMemberRemovedEventArgs^ UnwrapAllJoynSessionMemberRemovedEventArgs(Local<Value> value) {
     return AllJoynSessionMemberRemovedEventArgs::Unwrap<AllJoynSessionMemberRemovedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAllJoynSessionMemberRemovedEventArgs(Local<Object> exports) {
    AllJoynSessionMemberRemovedEventArgs::Init(exports);
  }

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





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

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



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

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

    private:

      AllJoynSessionLostEventArgs(::Windows::Devices::AllJoyn::AllJoynSessionLostEventArgs^ instance) {
        _instance = instance;
      }

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

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::Devices::AllJoyn::AllJoynSessionLostEventArgs^ winRtInstance;


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

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

      AllJoynSessionLostEventArgs *wrapperInstance = new AllJoynSessionLostEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynSessionLostEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::Devices::AllJoyn::AllJoynSessionLostEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Devices::AllJoyn::AllJoynSessionLostEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

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


    private:
      ::Windows::Devices::AllJoyn::AllJoynSessionLostEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAllJoynSessionLostEventArgs(::Windows::Devices::AllJoyn::AllJoynSessionLostEventArgs^ wintRtInstance);
      friend ::Windows::Devices::AllJoyn::AllJoynSessionLostEventArgs^ UnwrapAllJoynSessionLostEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> AllJoynSessionLostEventArgs::s_constructorTemplate;

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

  ::Windows::Devices::AllJoyn::AllJoynSessionLostEventArgs^ UnwrapAllJoynSessionLostEventArgs(Local<Value> value) {
     return AllJoynSessionLostEventArgs::Unwrap<AllJoynSessionLostEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAllJoynSessionLostEventArgs(Local<Object> exports) {
    AllJoynSessionLostEventArgs::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "setBusObject", SetBusObject);
          




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



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

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

    private:

      IAllJoynProducer(::Windows::Devices::AllJoyn::IAllJoynProducer^ instance) {
        _instance = instance;
      }

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

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::Devices::AllJoyn::IAllJoynProducer^ winRtInstance;


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

      IAllJoynProducer *wrapperInstance = new IAllJoynProducer(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::IAllJoynProducer^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::Devices::AllJoyn::IAllJoynProducer^ winRtInstance;
      try {
        winRtInstance = (::Windows::Devices::AllJoyn::IAllJoynProducer^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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


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

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

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

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





    private:
      ::Windows::Devices::AllJoyn::IAllJoynProducer^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIAllJoynProducer(::Windows::Devices::AllJoyn::IAllJoynProducer^ wintRtInstance);
      friend ::Windows::Devices::AllJoyn::IAllJoynProducer^ UnwrapIAllJoynProducer(Local<Value> value);
  };

  Persistent<FunctionTemplate> IAllJoynProducer::s_constructorTemplate;

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

  ::Windows::Devices::AllJoyn::IAllJoynProducer^ UnwrapIAllJoynProducer(Local<Value> value) {
     return IAllJoynProducer::Unwrap<IAllJoynProducer>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIAllJoynProducer(Local<Object> exports) {
    IAllJoynProducer::Init(exports);
  }

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


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


          
          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>("busAttachment").ToLocalChecked(), BusAttachmentGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("session").ToLocalChecked(), SessionGetter);

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



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

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

    private:

      AllJoynBusObject(::Windows::Devices::AllJoyn::AllJoynBusObject^ instance) {
        _instance = instance;
      }

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

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::Devices::AllJoyn::AllJoynBusObject^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynBusObject^>(info[0])) {
        try {
          winRtInstance = (::Windows::Devices::AllJoyn::AllJoynBusObject^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && info[0]->IsString())
      {
        try {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          winRtInstance = ref new ::Windows::Devices::AllJoyn::AllJoynBusObject(arg0);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && info[0]->IsString()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynBusAttachment^>(info[1]))
      {
        try {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Devices::AllJoyn::AllJoynBusAttachment^ arg1 = UnwrapAllJoynBusAttachment(info[1]);
          
          winRtInstance = ref new ::Windows::Devices::AllJoyn::AllJoynBusObject(arg0,arg1);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::Devices::AllJoyn::AllJoynBusObject();
        } 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());

      AllJoynBusObject *wrapperInstance = new AllJoynBusObject(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynBusObject^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::Devices::AllJoyn::AllJoynBusObject^ winRtInstance;
      try {
        winRtInstance = (::Windows::Devices::AllJoyn::AllJoynBusObject^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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


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

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

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

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

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

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

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

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::IAllJoynProducer^>(info[0]))
      {
        try
        {
          ::Windows::Devices::AllJoyn::IAllJoynProducer^ arg0 = UnwrapIAllJoynProducer(info[0]);
          
          wrapper->_instance->AddProducer(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 BusAttachmentGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

      try  {
        ::Windows::Devices::AllJoyn::AllJoynSession^ result = wrapper->_instance->Session;
        info.GetReturnValue().Set(WrapAllJoynSession(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"stopped", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynBusObject^>(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;
        }
        AllJoynBusObject *wrapper = AllJoynBusObject::Unwrap<AllJoynBusObject>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

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


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAllJoynBusObject(arg0);
                  wrappedArg1 = WrapAllJoynBusObjectStoppedEventArgs(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"stopped", str))) {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

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

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

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

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

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

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

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"stopped", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynBusObject^>(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;
          }
          AllJoynBusObject *wrapper = AllJoynBusObject::Unwrap<AllJoynBusObject>(info.This());
          wrapper->_instance->Stopped::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

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

      friend v8::Local<v8::Value> WrapAllJoynBusObject(::Windows::Devices::AllJoyn::AllJoynBusObject^ wintRtInstance);
      friend ::Windows::Devices::AllJoyn::AllJoynBusObject^ UnwrapAllJoynBusObject(Local<Value> value);
  };

  Persistent<FunctionTemplate> AllJoynBusObject::s_constructorTemplate;

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

  ::Windows::Devices::AllJoyn::AllJoynBusObject^ UnwrapAllJoynBusObject(Local<Value> value) {
     return AllJoynBusObject::Unwrap<AllJoynBusObject>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAllJoynBusObject(Local<Object> exports) {
    AllJoynBusObject::Init(exports);
  }

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





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

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



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

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

    private:

      AllJoynBusObjectStoppedEventArgs(::Windows::Devices::AllJoyn::AllJoynBusObjectStoppedEventArgs^ instance) {
        _instance = instance;
      }

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

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::Devices::AllJoyn::AllJoynBusObjectStoppedEventArgs^ winRtInstance;


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

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

      AllJoynBusObjectStoppedEventArgs *wrapperInstance = new AllJoynBusObjectStoppedEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynBusObjectStoppedEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::Devices::AllJoyn::AllJoynBusObjectStoppedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Devices::AllJoyn::AllJoynBusObjectStoppedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

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


    private:
      ::Windows::Devices::AllJoyn::AllJoynBusObjectStoppedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAllJoynBusObjectStoppedEventArgs(::Windows::Devices::AllJoyn::AllJoynBusObjectStoppedEventArgs^ wintRtInstance);
      friend ::Windows::Devices::AllJoyn::AllJoynBusObjectStoppedEventArgs^ UnwrapAllJoynBusObjectStoppedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> AllJoynBusObjectStoppedEventArgs::s_constructorTemplate;

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

  ::Windows::Devices::AllJoyn::AllJoynBusObjectStoppedEventArgs^ UnwrapAllJoynBusObjectStoppedEventArgs(Local<Value> value) {
     return AllJoynBusObjectStoppedEventArgs::Unwrap<AllJoynBusObjectStoppedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAllJoynBusObjectStoppedEventArgs(Local<Object> exports) {
    AllJoynBusObjectStoppedEventArgs::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "accept", Accept);
          




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



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

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

    private:

      IAllJoynAcceptSessionJoiner(::Windows::Devices::AllJoyn::IAllJoynAcceptSessionJoiner^ instance) {
        _instance = instance;
      }

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

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::Devices::AllJoyn::IAllJoynAcceptSessionJoiner^ winRtInstance;


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

      IAllJoynAcceptSessionJoiner *wrapperInstance = new IAllJoynAcceptSessionJoiner(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::IAllJoynAcceptSessionJoiner^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::Devices::AllJoyn::IAllJoynAcceptSessionJoiner^ winRtInstance;
      try {
        winRtInstance = (::Windows::Devices::AllJoyn::IAllJoynAcceptSessionJoiner^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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


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

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

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

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





    private:
      ::Windows::Devices::AllJoyn::IAllJoynAcceptSessionJoiner^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIAllJoynAcceptSessionJoiner(::Windows::Devices::AllJoyn::IAllJoynAcceptSessionJoiner^ wintRtInstance);
      friend ::Windows::Devices::AllJoyn::IAllJoynAcceptSessionJoiner^ UnwrapIAllJoynAcceptSessionJoiner(Local<Value> value);
  };

  Persistent<FunctionTemplate> IAllJoynAcceptSessionJoiner::s_constructorTemplate;

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

  ::Windows::Devices::AllJoyn::IAllJoynAcceptSessionJoiner^ UnwrapIAllJoynAcceptSessionJoiner(Local<Value> value) {
     return IAllJoynAcceptSessionJoiner::Unwrap<IAllJoynAcceptSessionJoiner>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIAllJoynAcceptSessionJoiner(Local<Object> exports) {
    IAllJoynAcceptSessionJoiner::Init(exports);
  }

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





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

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



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

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

    private:

      AllJoynProducerStoppedEventArgs(::Windows::Devices::AllJoyn::AllJoynProducerStoppedEventArgs^ instance) {
        _instance = instance;
      }

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

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::Devices::AllJoyn::AllJoynProducerStoppedEventArgs^ winRtInstance;


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

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

      AllJoynProducerStoppedEventArgs *wrapperInstance = new AllJoynProducerStoppedEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynProducerStoppedEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::Devices::AllJoyn::AllJoynProducerStoppedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Devices::AllJoyn::AllJoynProducerStoppedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

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


    private:
      ::Windows::Devices::AllJoyn::AllJoynProducerStoppedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAllJoynProducerStoppedEventArgs(::Windows::Devices::AllJoyn::AllJoynProducerStoppedEventArgs^ wintRtInstance);
      friend ::Windows::Devices::AllJoyn::AllJoynProducerStoppedEventArgs^ UnwrapAllJoynProducerStoppedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> AllJoynProducerStoppedEventArgs::s_constructorTemplate;

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

  ::Windows::Devices::AllJoyn::AllJoynProducerStoppedEventArgs^ UnwrapAllJoynProducerStoppedEventArgs(Local<Value> value) {
     return AllJoynProducerStoppedEventArgs::Unwrap<AllJoynProducerStoppedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAllJoynProducerStoppedEventArgs(Local<Object> exports) {
    AllJoynProducerStoppedEventArgs::Init(exports);
  }

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





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

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



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

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

    private:

      AllJoynWatcherStoppedEventArgs(::Windows::Devices::AllJoyn::AllJoynWatcherStoppedEventArgs^ instance) {
        _instance = instance;
      }

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

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::Devices::AllJoyn::AllJoynWatcherStoppedEventArgs^ winRtInstance;


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

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

      AllJoynWatcherStoppedEventArgs *wrapperInstance = new AllJoynWatcherStoppedEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynWatcherStoppedEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::Devices::AllJoyn::AllJoynWatcherStoppedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Devices::AllJoyn::AllJoynWatcherStoppedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

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


    private:
      ::Windows::Devices::AllJoyn::AllJoynWatcherStoppedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAllJoynWatcherStoppedEventArgs(::Windows::Devices::AllJoyn::AllJoynWatcherStoppedEventArgs^ wintRtInstance);
      friend ::Windows::Devices::AllJoyn::AllJoynWatcherStoppedEventArgs^ UnwrapAllJoynWatcherStoppedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> AllJoynWatcherStoppedEventArgs::s_constructorTemplate;

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

  ::Windows::Devices::AllJoyn::AllJoynWatcherStoppedEventArgs^ UnwrapAllJoynWatcherStoppedEventArgs(Local<Value> value) {
     return AllJoynWatcherStoppedEventArgs::Unwrap<AllJoynWatcherStoppedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAllJoynWatcherStoppedEventArgs(Local<Object> exports) {
    AllJoynWatcherStoppedEventArgs::Init(exports);
  }

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





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

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



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

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

    private:

      AllJoynServiceInfoRemovedEventArgs(::Windows::Devices::AllJoyn::AllJoynServiceInfoRemovedEventArgs^ instance) {
        _instance = instance;
      }

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

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::Devices::AllJoyn::AllJoynServiceInfoRemovedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynServiceInfoRemovedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::Devices::AllJoyn::AllJoynServiceInfoRemovedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && info[0]->IsString())
      {
        try {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          winRtInstance = ref new ::Windows::Devices::AllJoyn::AllJoynServiceInfoRemovedEventArgs(arg0);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

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

      AllJoynServiceInfoRemovedEventArgs *wrapperInstance = new AllJoynServiceInfoRemovedEventArgs(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynServiceInfoRemovedEventArgs^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::Devices::AllJoyn::AllJoynServiceInfoRemovedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Devices::AllJoyn::AllJoynServiceInfoRemovedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

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


    private:
      ::Windows::Devices::AllJoyn::AllJoynServiceInfoRemovedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAllJoynServiceInfoRemovedEventArgs(::Windows::Devices::AllJoyn::AllJoynServiceInfoRemovedEventArgs^ wintRtInstance);
      friend ::Windows::Devices::AllJoyn::AllJoynServiceInfoRemovedEventArgs^ UnwrapAllJoynServiceInfoRemovedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> AllJoynServiceInfoRemovedEventArgs::s_constructorTemplate;

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

  ::Windows::Devices::AllJoyn::AllJoynServiceInfoRemovedEventArgs^ UnwrapAllJoynServiceInfoRemovedEventArgs(Local<Value> value) {
     return AllJoynServiceInfoRemovedEventArgs::Unwrap<AllJoynServiceInfoRemovedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAllJoynServiceInfoRemovedEventArgs(Local<Object> exports) {
    AllJoynServiceInfoRemovedEventArgs::Init(exports);
  }

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





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

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



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

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

    private:

      AllJoynMessageInfo(::Windows::Devices::AllJoyn::AllJoynMessageInfo^ instance) {
        _instance = instance;
      }

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

      Local<FunctionTemplate> localRef = Nan::New<FunctionTemplate>(s_constructorTemplate);

      // in case the constructor was called without the new operator
      if (!localRef->HasInstance(info.This())) {
        if (info.Length() > 0) {
          std::unique_ptr<Local<Value> []> constructorArgs(new Local<Value>[info.Length()]);

          Local<Value> *argsPtr = constructorArgs.get();
          for (int i = 0; i < info.Length(); i++) {
            argsPtr[i] = info[i];
          }

          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), constructorArgs.get());
          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        } else {
          MaybeLocal<Object> res = Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(), info.Length(), nullptr);

          if (res.IsEmpty()) {
            return;
          }

          info.GetReturnValue().Set(res.ToLocalChecked());
          return;
        }
      }

      ::Windows::Devices::AllJoyn::AllJoynMessageInfo^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynMessageInfo^>(info[0])) {
        try {
          winRtInstance = (::Windows::Devices::AllJoyn::AllJoynMessageInfo^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && info[0]->IsString())
      {
        try {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          winRtInstance = ref new ::Windows::Devices::AllJoyn::AllJoynMessageInfo(arg0);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

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

      AllJoynMessageInfo *wrapperInstance = new AllJoynMessageInfo(winRtInstance);
      wrapperInstance->Wrap(info.This());

      info.GetReturnValue().Set(info.This());
    }


      
    static void CastFrom(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;
      if (info.Length() < 1 || !NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::AllJoyn::AllJoynMessageInfo^>(info[0])) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no object provided, or given object could not be casted to requested type")));
        return;
      }

      ::Windows::Devices::AllJoyn::AllJoynMessageInfo^ winRtInstance;
      try {
        winRtInstance = (::Windows::Devices::AllJoyn::AllJoynMessageInfo^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

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





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

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

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

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


    private:
      ::Windows::Devices::AllJoyn::AllJoynMessageInfo^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAllJoynMessageInfo(::Windows::Devices::AllJoyn::AllJoynMessageInfo^ wintRtInstance);
      friend ::Windows::Devices::AllJoyn::AllJoynMessageInfo^ UnwrapAllJoynMessageInfo(Local<Value> value);
  };

  Persistent<FunctionTemplate> AllJoynMessageInfo::s_constructorTemplate;

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

  ::Windows::Devices::AllJoyn::AllJoynMessageInfo^ UnwrapAllJoynMessageInfo(Local<Value> value) {
     return AllJoynMessageInfo::Unwrap<AllJoynMessageInfo>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAllJoynMessageInfo(Local<Object> exports) {
    AllJoynMessageInfo::Init(exports);
  }


} } } } 

NAN_MODULE_INIT(init) {
  // We ignore failures for now since it probably means that
  // the initialization already happened for STA, and that's cool

  CoInitializeEx(nullptr, COINIT_MULTITHREADED);

  /*
  if (FAILED(CoInitializeEx(nullptr, COINIT_MULTITHREADED))) {
    Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"error in CoInitializeEx()")));
    return;
  }
  */

      NodeRT::Windows::Devices::AllJoyn::InitAllJoynAuthenticationMechanismEnum(target);
      NodeRT::Windows::Devices::AllJoyn::InitAllJoynBusAttachmentStateEnum(target);
      NodeRT::Windows::Devices::AllJoyn::InitAllJoynTrafficTypeEnum(target);
      NodeRT::Windows::Devices::AllJoyn::InitAllJoynSessionLostReasonEnum(target);
      NodeRT::Windows::Devices::AllJoyn::InitAllJoynStatus(target);
      NodeRT::Windows::Devices::AllJoyn::InitAllJoynAboutData(target);
      NodeRT::Windows::Devices::AllJoyn::InitAllJoynBusAttachment(target);
      NodeRT::Windows::Devices::AllJoyn::InitAllJoynBusAttachmentStateChangedEventArgs(target);
      NodeRT::Windows::Devices::AllJoyn::InitAllJoynCredentialsRequestedEventArgs(target);
      NodeRT::Windows::Devices::AllJoyn::InitAllJoynCredentialsVerificationRequestedEventArgs(target);
      NodeRT::Windows::Devices::AllJoyn::InitAllJoynAuthenticationCompleteEventArgs(target);
      NodeRT::Windows::Devices::AllJoyn::InitAllJoynServiceInfo(target);
      NodeRT::Windows::Devices::AllJoyn::InitAllJoynAboutDataView(target);
      NodeRT::Windows::Devices::AllJoyn::InitAllJoynAcceptSessionJoinerEventArgs(target);
      NodeRT::Windows::Devices::AllJoyn::InitAllJoynSessionJoinedEventArgs(target);
      NodeRT::Windows::Devices::AllJoyn::InitAllJoynCredentials(target);
      NodeRT::Windows::Devices::AllJoyn::InitAllJoynSession(target);
      NodeRT::Windows::Devices::AllJoyn::InitAllJoynSessionMemberAddedEventArgs(target);
      NodeRT::Windows::Devices::AllJoyn::InitAllJoynSessionMemberRemovedEventArgs(target);
      NodeRT::Windows::Devices::AllJoyn::InitAllJoynSessionLostEventArgs(target);
      NodeRT::Windows::Devices::AllJoyn::InitIAllJoynProducer(target);
      NodeRT::Windows::Devices::AllJoyn::InitAllJoynBusObject(target);
      NodeRT::Windows::Devices::AllJoyn::InitAllJoynBusObjectStoppedEventArgs(target);
      NodeRT::Windows::Devices::AllJoyn::InitIAllJoynAcceptSessionJoiner(target);
      NodeRT::Windows::Devices::AllJoyn::InitAllJoynProducerStoppedEventArgs(target);
      NodeRT::Windows::Devices::AllJoyn::InitAllJoynWatcherStoppedEventArgs(target);
      NodeRT::Windows::Devices::AllJoyn::InitAllJoynServiceInfoRemovedEventArgs(target);
      NodeRT::Windows::Devices::AllJoyn::InitAllJoynMessageInfo(target);


  NodeRT::Utils::RegisterNameSpace("Windows.Devices.AllJoyn", target);
}



NODE_MODULE(binding, init)