// 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 Networking { namespace Vpn { 
  v8::Local<v8::Value> WrapIVpnPlugIn(::Windows::Networking::Vpn::IVpnPlugIn^ wintRtInstance);
  ::Windows::Networking::Vpn::IVpnPlugIn^ UnwrapIVpnPlugIn(Local<Value> value);
  
  v8::Local<v8::Value> WrapIVpnCustomPrompt(::Windows::Networking::Vpn::IVpnCustomPrompt^ wintRtInstance);
  ::Windows::Networking::Vpn::IVpnCustomPrompt^ UnwrapIVpnCustomPrompt(Local<Value> value);
  
  v8::Local<v8::Value> WrapIVpnRouteFactory(::Windows::Networking::Vpn::IVpnRouteFactory^ wintRtInstance);
  ::Windows::Networking::Vpn::IVpnRouteFactory^ UnwrapIVpnRouteFactory(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnRoute(::Windows::Networking::Vpn::VpnRoute^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnRoute^ UnwrapVpnRoute(Local<Value> value);
  
  v8::Local<v8::Value> WrapIVpnNamespaceInfoFactory(::Windows::Networking::Vpn::IVpnNamespaceInfoFactory^ wintRtInstance);
  ::Windows::Networking::Vpn::IVpnNamespaceInfoFactory^ UnwrapIVpnNamespaceInfoFactory(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnNamespaceInfo(::Windows::Networking::Vpn::VpnNamespaceInfo^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnNamespaceInfo^ UnwrapVpnNamespaceInfo(Local<Value> value);
  
  v8::Local<v8::Value> WrapIVpnInterfaceIdFactory(::Windows::Networking::Vpn::IVpnInterfaceIdFactory^ wintRtInstance);
  ::Windows::Networking::Vpn::IVpnInterfaceIdFactory^ UnwrapIVpnInterfaceIdFactory(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnInterfaceId(::Windows::Networking::Vpn::VpnInterfaceId^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnInterfaceId^ UnwrapVpnInterfaceId(Local<Value> value);
  
  v8::Local<v8::Value> WrapIVpnCredential(::Windows::Networking::Vpn::IVpnCredential^ wintRtInstance);
  ::Windows::Networking::Vpn::IVpnCredential^ UnwrapIVpnCredential(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnRouteAssignment(::Windows::Networking::Vpn::VpnRouteAssignment^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnRouteAssignment^ UnwrapVpnRouteAssignment(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnNamespaceAssignment(::Windows::Networking::Vpn::VpnNamespaceAssignment^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnNamespaceAssignment^ UnwrapVpnNamespaceAssignment(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnPickedCredential(::Windows::Networking::Vpn::VpnPickedCredential^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnPickedCredential^ UnwrapVpnPickedCredential(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnPacketBuffer(::Windows::Networking::Vpn::VpnPacketBuffer^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnPacketBuffer^ UnwrapVpnPacketBuffer(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnChannelConfiguration(::Windows::Networking::Vpn::VpnChannelConfiguration^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnChannelConfiguration^ UnwrapVpnChannelConfiguration(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnChannel(::Windows::Networking::Vpn::VpnChannel^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnChannel^ UnwrapVpnChannel(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnChannelActivityEventArgs(::Windows::Networking::Vpn::VpnChannelActivityEventArgs^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnChannelActivityEventArgs^ UnwrapVpnChannelActivityEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnSystemHealth(::Windows::Networking::Vpn::VpnSystemHealth^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnSystemHealth^ UnwrapVpnSystemHealth(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnDomainNameAssignment(::Windows::Networking::Vpn::VpnDomainNameAssignment^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnDomainNameAssignment^ UnwrapVpnDomainNameAssignment(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnChannelActivityStateChangedArgs(::Windows::Networking::Vpn::VpnChannelActivityStateChangedArgs^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnChannelActivityStateChangedArgs^ UnwrapVpnChannelActivityStateChangedArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapIVpnCustomPromptElement(::Windows::Networking::Vpn::IVpnCustomPromptElement^ wintRtInstance);
  ::Windows::Networking::Vpn::IVpnCustomPromptElement^ UnwrapIVpnCustomPromptElement(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnCredential(::Windows::Networking::Vpn::VpnCredential^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnCredential^ UnwrapVpnCredential(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnTrafficFilterAssignment(::Windows::Networking::Vpn::VpnTrafficFilterAssignment^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnTrafficFilterAssignment^ UnwrapVpnTrafficFilterAssignment(Local<Value> value);
  
  v8::Local<v8::Value> WrapIVpnChannelStatics(::Windows::Networking::Vpn::IVpnChannelStatics^ wintRtInstance);
  ::Windows::Networking::Vpn::IVpnChannelStatics^ UnwrapIVpnChannelStatics(Local<Value> value);
  
  v8::Local<v8::Value> WrapIVpnPacketBufferFactory(::Windows::Networking::Vpn::IVpnPacketBufferFactory^ wintRtInstance);
  ::Windows::Networking::Vpn::IVpnPacketBufferFactory^ UnwrapIVpnPacketBufferFactory(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnAppId(::Windows::Networking::Vpn::VpnAppId^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnAppId^ UnwrapVpnAppId(Local<Value> value);
  
  v8::Local<v8::Value> WrapIVpnDomainNameInfoFactory(::Windows::Networking::Vpn::IVpnDomainNameInfoFactory^ wintRtInstance);
  ::Windows::Networking::Vpn::IVpnDomainNameInfoFactory^ UnwrapIVpnDomainNameInfoFactory(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnDomainNameInfo(::Windows::Networking::Vpn::VpnDomainNameInfo^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnDomainNameInfo^ UnwrapVpnDomainNameInfo(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnTrafficFilter(::Windows::Networking::Vpn::VpnTrafficFilter^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnTrafficFilter^ UnwrapVpnTrafficFilter(Local<Value> value);
  
  v8::Local<v8::Value> WrapIVpnProfile(::Windows::Networking::Vpn::IVpnProfile^ wintRtInstance);
  ::Windows::Networking::Vpn::IVpnProfile^ UnwrapIVpnProfile(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnPacketBufferList(::Windows::Networking::Vpn::VpnPacketBufferList^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnPacketBufferList^ UnwrapVpnPacketBufferList(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnCustomEditBox(::Windows::Networking::Vpn::VpnCustomEditBox^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnCustomEditBox^ UnwrapVpnCustomEditBox(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnCustomPromptTextInput(::Windows::Networking::Vpn::VpnCustomPromptTextInput^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnCustomPromptTextInput^ UnwrapVpnCustomPromptTextInput(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnCustomComboBox(::Windows::Networking::Vpn::VpnCustomComboBox^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnCustomComboBox^ UnwrapVpnCustomComboBox(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnCustomPromptOptionSelector(::Windows::Networking::Vpn::VpnCustomPromptOptionSelector^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnCustomPromptOptionSelector^ UnwrapVpnCustomPromptOptionSelector(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnCustomTextBox(::Windows::Networking::Vpn::VpnCustomTextBox^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnCustomTextBox^ UnwrapVpnCustomTextBox(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnCustomPromptText(::Windows::Networking::Vpn::VpnCustomPromptText^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnCustomPromptText^ UnwrapVpnCustomPromptText(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnCustomCheckBox(::Windows::Networking::Vpn::VpnCustomCheckBox^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnCustomCheckBox^ UnwrapVpnCustomCheckBox(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnCustomPromptBooleanInput(::Windows::Networking::Vpn::VpnCustomPromptBooleanInput^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnCustomPromptBooleanInput^ UnwrapVpnCustomPromptBooleanInput(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnCustomErrorBox(::Windows::Networking::Vpn::VpnCustomErrorBox^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnCustomErrorBox^ UnwrapVpnCustomErrorBox(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnPlugInProfile(::Windows::Networking::Vpn::VpnPlugInProfile^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnPlugInProfile^ UnwrapVpnPlugInProfile(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnNativeProfile(::Windows::Networking::Vpn::VpnNativeProfile^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnNativeProfile^ UnwrapVpnNativeProfile(Local<Value> value);
  
  v8::Local<v8::Value> WrapVpnManagementAgent(::Windows::Networking::Vpn::VpnManagementAgent^ wintRtInstance);
  ::Windows::Networking::Vpn::VpnManagementAgent^ UnwrapVpnManagementAgent(Local<Value> value);
  



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

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

    Nan::Set(exports, Nan::New<String>("VpnDataPathType").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("send").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnDataPathType::Send)));
    Nan::Set(enumObject, Nan::New<String>("receive").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnDataPathType::Receive)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("VpnChannelActivityEventType").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("idle").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnChannelActivityEventType::Idle)));
    Nan::Set(enumObject, Nan::New<String>("active").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnChannelActivityEventType::Active)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("VpnCredentialType").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("usernamePassword").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnCredentialType::UsernamePassword)));
    Nan::Set(enumObject, Nan::New<String>("usernameOtpPin").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnCredentialType::UsernameOtpPin)));
    Nan::Set(enumObject, Nan::New<String>("usernamePasswordAndPin").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnCredentialType::UsernamePasswordAndPin)));
    Nan::Set(enumObject, Nan::New<String>("usernamePasswordChange").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnCredentialType::UsernamePasswordChange)));
    Nan::Set(enumObject, Nan::New<String>("smartCard").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnCredentialType::SmartCard)));
    Nan::Set(enumObject, Nan::New<String>("protectedCertificate").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnCredentialType::ProtectedCertificate)));
    Nan::Set(enumObject, Nan::New<String>("unProtectedCertificate").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnCredentialType::UnProtectedCertificate)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("VpnPacketBufferStatus").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("ok").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnPacketBufferStatus::Ok)));
    Nan::Set(enumObject, Nan::New<String>("invalidBufferSize").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnPacketBufferStatus::InvalidBufferSize)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("VpnChannelRequestCredentialsOptions").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnChannelRequestCredentialsOptions::None)));
    Nan::Set(enumObject, Nan::New<String>("retrying").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnChannelRequestCredentialsOptions::Retrying)));
    Nan::Set(enumObject, Nan::New<String>("useForSingleSignIn").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnChannelRequestCredentialsOptions::UseForSingleSignIn)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("VpnDomainNameType").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("suffix").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnDomainNameType::Suffix)));
    Nan::Set(enumObject, Nan::New<String>("fullyQualified").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnDomainNameType::FullyQualified)));
    Nan::Set(enumObject, Nan::New<String>("reserved").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnDomainNameType::Reserved)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("VpnAppIdType").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("packageFamilyName").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnAppIdType::PackageFamilyName)));
    Nan::Set(enumObject, Nan::New<String>("fullyQualifiedBinaryName").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnAppIdType::FullyQualifiedBinaryName)));
    Nan::Set(enumObject, Nan::New<String>("filePath").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnAppIdType::FilePath)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("VpnIPProtocol").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnIPProtocol::None)));
    Nan::Set(enumObject, Nan::New<String>("icmp").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnIPProtocol::Icmp)));
    Nan::Set(enumObject, Nan::New<String>("igmp").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnIPProtocol::Igmp)));
    Nan::Set(enumObject, Nan::New<String>("tcp").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnIPProtocol::Tcp)));
    Nan::Set(enumObject, Nan::New<String>("udp").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnIPProtocol::Udp)));
    Nan::Set(enumObject, Nan::New<String>("ipv6Icmp").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnIPProtocol::Ipv6Icmp)));
    Nan::Set(enumObject, Nan::New<String>("pgm").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnIPProtocol::Pgm)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("VpnRoutingPolicyType").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("splitRouting").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnRoutingPolicyType::SplitRouting)));
    Nan::Set(enumObject, Nan::New<String>("forceAllTrafficOverVpn").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnRoutingPolicyType::ForceAllTrafficOverVpn)));
  }

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

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

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

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

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

    Nan::Set(exports, Nan::New<String>("VpnNativeProtocolType").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("pptp").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnNativeProtocolType::Pptp)));
    Nan::Set(enumObject, Nan::New<String>("l2tp").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnNativeProtocolType::L2tp)));
    Nan::Set(enumObject, Nan::New<String>("ipsecIkev2").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnNativeProtocolType::IpsecIkev2)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("VpnAuthenticationMethod").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("mschapv2").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnAuthenticationMethod::Mschapv2)));
    Nan::Set(enumObject, Nan::New<String>("eap").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnAuthenticationMethod::Eap)));
    Nan::Set(enumObject, Nan::New<String>("certificate").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnAuthenticationMethod::Certificate)));
    Nan::Set(enumObject, Nan::New<String>("presharedKey").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnAuthenticationMethod::PresharedKey)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("VpnManagementErrorStatus").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("ok").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnManagementErrorStatus::Ok)));
    Nan::Set(enumObject, Nan::New<String>("other").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnManagementErrorStatus::Other)));
    Nan::Set(enumObject, Nan::New<String>("invalidXmlSyntax").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnManagementErrorStatus::InvalidXmlSyntax)));
    Nan::Set(enumObject, Nan::New<String>("profileNameTooLong").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnManagementErrorStatus::ProfileNameTooLong)));
    Nan::Set(enumObject, Nan::New<String>("profileInvalidAppId").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnManagementErrorStatus::ProfileInvalidAppId)));
    Nan::Set(enumObject, Nan::New<String>("accessDenied").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnManagementErrorStatus::AccessDenied)));
    Nan::Set(enumObject, Nan::New<String>("cannotFindProfile").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnManagementErrorStatus::CannotFindProfile)));
    Nan::Set(enumObject, Nan::New<String>("alreadyDisconnecting").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnManagementErrorStatus::AlreadyDisconnecting)));
    Nan::Set(enumObject, Nan::New<String>("alreadyConnected").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnManagementErrorStatus::AlreadyConnected)));
    Nan::Set(enumObject, Nan::New<String>("generalAuthenticationFailure").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnManagementErrorStatus::GeneralAuthenticationFailure)));
    Nan::Set(enumObject, Nan::New<String>("eapFailure").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnManagementErrorStatus::EapFailure)));
    Nan::Set(enumObject, Nan::New<String>("smartCardFailure").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnManagementErrorStatus::SmartCardFailure)));
    Nan::Set(enumObject, Nan::New<String>("certificateFailure").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnManagementErrorStatus::CertificateFailure)));
    Nan::Set(enumObject, Nan::New<String>("serverConfiguration").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnManagementErrorStatus::ServerConfiguration)));
    Nan::Set(enumObject, Nan::New<String>("noConnection").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnManagementErrorStatus::NoConnection)));
    Nan::Set(enumObject, Nan::New<String>("serverConnection").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnManagementErrorStatus::ServerConnection)));
    Nan::Set(enumObject, Nan::New<String>("userNamePassword").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnManagementErrorStatus::UserNamePassword)));
    Nan::Set(enumObject, Nan::New<String>("dnsNotResolvable").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnManagementErrorStatus::DnsNotResolvable)));
    Nan::Set(enumObject, Nan::New<String>("invalidIP").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::Vpn::VpnManagementErrorStatus::InvalidIP)));
  }



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


          
            Nan::SetPrototypeMethod(localRef, "connect", Connect);
            Nan::SetPrototypeMethod(localRef, "disconnect", Disconnect);
            Nan::SetPrototypeMethod(localRef, "getKeepAlivePayload", GetKeepAlivePayload);
            Nan::SetPrototypeMethod(localRef, "encapsulate", Encapsulate);
            Nan::SetPrototypeMethod(localRef, "decapsulate", Decapsulate);
          




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



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

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

    private:

      IVpnPlugIn(::Windows::Networking::Vpn::IVpnPlugIn^ 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::Networking::Vpn::IVpnPlugIn^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnPlugIn^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(info[0]))
      {
        try
        {
          ::Windows::Networking::Vpn::VpnChannel^ arg0 = UnwrapVpnChannel(info[0]);
          
          wrapper->_instance->Connect(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 Disconnect(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnPlugIn^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(info[0]))
      {
        try
        {
          ::Windows::Networking::Vpn::VpnChannel^ arg0 = UnwrapVpnChannel(info[0]);
          
          wrapper->_instance->Disconnect(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 GetKeepAlivePayload(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnPlugIn^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(info[0]))
      {
        try
        {
          ::Windows::Networking::Vpn::VpnChannel^ arg0 = UnwrapVpnChannel(info[0]);
          ::Windows::Networking::Vpn::VpnPacketBuffer^ arg1;
          
          wrapper->_instance->GetKeepAlivePayload(arg0, &arg1);
          Local<Object> resObj = Nan::New<Object>();
          Nan::Set(resObj, Nan::New<String>("keepAlivePacket").ToLocalChecked(), NodeRT::Utils::CreateExternalWinRTObject("Windows.Networking.Vpn", "VpnPacketBuffer", arg1));
          info.GetReturnValue().Set(resObj);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Encapsulate(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnPlugIn^>(info.This())) {
        return;
      }

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

      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPacketBufferList^>(info[1])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPacketBufferList^>(info[2]))
      {
        try
        {
          ::Windows::Networking::Vpn::VpnChannel^ arg0 = UnwrapVpnChannel(info[0]);
          ::Windows::Networking::Vpn::VpnPacketBufferList^ arg1 = UnwrapVpnPacketBufferList(info[1]);
          ::Windows::Networking::Vpn::VpnPacketBufferList^ arg2 = UnwrapVpnPacketBufferList(info[2]);
          
          wrapper->_instance->Encapsulate(arg0, arg1, arg2);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Decapsulate(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnPlugIn^>(info.This())) {
        return;
      }

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

      if (info.Length() == 4
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPacketBuffer^>(info[1])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPacketBufferList^>(info[2])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPacketBufferList^>(info[3]))
      {
        try
        {
          ::Windows::Networking::Vpn::VpnChannel^ arg0 = UnwrapVpnChannel(info[0]);
          ::Windows::Networking::Vpn::VpnPacketBuffer^ arg1 = UnwrapVpnPacketBuffer(info[1]);
          ::Windows::Networking::Vpn::VpnPacketBufferList^ arg2 = UnwrapVpnPacketBufferList(info[2]);
          ::Windows::Networking::Vpn::VpnPacketBufferList^ arg3 = UnwrapVpnPacketBufferList(info[3]);
          
          wrapper->_instance->Decapsulate(arg0, arg1, arg2, arg3);
          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::Networking::Vpn::IVpnPlugIn^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIVpnPlugIn(::Windows::Networking::Vpn::IVpnPlugIn^ wintRtInstance);
      friend ::Windows::Networking::Vpn::IVpnPlugIn^ UnwrapIVpnPlugIn(Local<Value> value);
  };

  Persistent<FunctionTemplate> IVpnPlugIn::s_constructorTemplate;

  v8::Local<v8::Value> WrapIVpnPlugIn(::Windows::Networking::Vpn::IVpnPlugIn^ 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>(IVpnPlugIn::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::IVpnPlugIn^ UnwrapIVpnPlugIn(Local<Value> value) {
     return IVpnPlugIn::Unwrap<IVpnPlugIn>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIVpnPlugIn(Local<Object> exports) {
    IVpnPlugIn::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("bordered").ToLocalChecked(), BorderedGetter, BorderedSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("compulsory").ToLocalChecked(), CompulsoryGetter, CompulsorySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("label").ToLocalChecked(), LabelGetter, LabelSetter);

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



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

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

    private:

      IVpnCustomPrompt(::Windows::Networking::Vpn::IVpnCustomPrompt^ 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::Networking::Vpn::IVpnCustomPrompt^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnCustomPrompt^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->Bordered;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BorderedSetter(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::Networking::Vpn::IVpnCustomPrompt^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnCustomPrompt^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->Compulsory;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CompulsorySetter(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::Networking::Vpn::IVpnCustomPrompt^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnCustomPrompt^>(info.This())) {
        return;
      }

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

      try  {
        Platform::String^ result = wrapper->_instance->Label;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void LabelSetter(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::Networking::Vpn::IVpnCustomPrompt^>(info.This())) {
        return;
      }

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

      try {

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

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


    private:
      ::Windows::Networking::Vpn::IVpnCustomPrompt^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIVpnCustomPrompt(::Windows::Networking::Vpn::IVpnCustomPrompt^ wintRtInstance);
      friend ::Windows::Networking::Vpn::IVpnCustomPrompt^ UnwrapIVpnCustomPrompt(Local<Value> value);
  };

  Persistent<FunctionTemplate> IVpnCustomPrompt::s_constructorTemplate;

  v8::Local<v8::Value> WrapIVpnCustomPrompt(::Windows::Networking::Vpn::IVpnCustomPrompt^ 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>(IVpnCustomPrompt::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::IVpnCustomPrompt^ UnwrapIVpnCustomPrompt(Local<Value> value) {
     return IVpnCustomPrompt::Unwrap<IVpnCustomPrompt>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIVpnCustomPrompt(Local<Object> exports) {
    IVpnCustomPrompt::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "createVpnRoute", CreateVpnRoute);
          




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



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

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

    private:

      IVpnRouteFactory(::Windows::Networking::Vpn::IVpnRouteFactory^ 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::Networking::Vpn::IVpnRouteFactory^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnRouteFactory^>(info.This())) {
        return;
      }

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

      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::HostName^>(info[0])
        && info[1]->IsInt32())
      {
        try
        {
          ::Windows::Networking::HostName^ arg0 = dynamic_cast<::Windows::Networking::HostName^>(NodeRT::Utils::GetObjectInstance(info[0]));
          unsigned char arg1 = static_cast<unsigned char>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          ::Windows::Networking::Vpn::VpnRoute^ result;
          result = wrapper->_instance->CreateVpnRoute(arg0, arg1);
          info.GetReturnValue().Set(WrapVpnRoute(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





    private:
      ::Windows::Networking::Vpn::IVpnRouteFactory^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIVpnRouteFactory(::Windows::Networking::Vpn::IVpnRouteFactory^ wintRtInstance);
      friend ::Windows::Networking::Vpn::IVpnRouteFactory^ UnwrapIVpnRouteFactory(Local<Value> value);
  };

  Persistent<FunctionTemplate> IVpnRouteFactory::s_constructorTemplate;

  v8::Local<v8::Value> WrapIVpnRouteFactory(::Windows::Networking::Vpn::IVpnRouteFactory^ 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>(IVpnRouteFactory::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::IVpnRouteFactory^ UnwrapIVpnRouteFactory(Local<Value> value) {
     return IVpnRouteFactory::Unwrap<IVpnRouteFactory>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIVpnRouteFactory(Local<Object> exports) {
    IVpnRouteFactory::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("prefixSize").ToLocalChecked(), PrefixSizeGetter, PrefixSizeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("address").ToLocalChecked(), AddressGetter, AddressSetter);

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



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

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

    private:

      VpnRoute(::Windows::Networking::Vpn::VpnRoute^ 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::Networking::Vpn::VpnRoute^ winRtInstance;


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

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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnRoute^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnRoute^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnRoute^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnRoute^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Networking::HostName^ winRtValue = dynamic_cast<::Windows::Networking::HostName^>(NodeRT::Utils::GetObjectInstance(value));

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


    private:
      ::Windows::Networking::Vpn::VpnRoute^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnRoute(::Windows::Networking::Vpn::VpnRoute^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnRoute^ UnwrapVpnRoute(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnRoute::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnRoute(::Windows::Networking::Vpn::VpnRoute^ 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>(VpnRoute::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnRoute^ UnwrapVpnRoute(Local<Value> value) {
     return VpnRoute::Unwrap<VpnRoute>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnRoute(Local<Object> exports) {
    VpnRoute::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "createVpnNamespaceInfo", CreateVpnNamespaceInfo);
          




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



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

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

    private:

      IVpnNamespaceInfoFactory(::Windows::Networking::Vpn::IVpnNamespaceInfoFactory^ 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::Networking::Vpn::IVpnNamespaceInfoFactory^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnNamespaceInfoFactory^>(info.This())) {
        return;
      }

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

      if (info.Length() == 3
        && info[0]->IsString()
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IVector<::Windows::Networking::HostName^>^>(info[1]) || info[1]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IVector<::Windows::Networking::HostName^>^>(info[2]) || info[2]->IsArray()))
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Foundation::Collections::IVector<::Windows::Networking::HostName^>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IVector<::Windows::Networking::HostName^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Networking::HostName^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::HostName^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Networking::HostName^ {
                   return dynamic_cast<::Windows::Networking::HostName^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IVector<::Windows::Networking::HostName^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          ::Windows::Foundation::Collections::IVector<::Windows::Networking::HostName^>^ arg2 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IVector<::Windows::Networking::HostName^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Networking::HostName^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::HostName^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Networking::HostName^ {
                   return dynamic_cast<::Windows::Networking::HostName^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IVector<::Windows::Networking::HostName^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[2]);
          
          ::Windows::Networking::Vpn::VpnNamespaceInfo^ result;
          result = wrapper->_instance->CreateVpnNamespaceInfo(arg0, arg1, arg2);
          info.GetReturnValue().Set(WrapVpnNamespaceInfo(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





    private:
      ::Windows::Networking::Vpn::IVpnNamespaceInfoFactory^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIVpnNamespaceInfoFactory(::Windows::Networking::Vpn::IVpnNamespaceInfoFactory^ wintRtInstance);
      friend ::Windows::Networking::Vpn::IVpnNamespaceInfoFactory^ UnwrapIVpnNamespaceInfoFactory(Local<Value> value);
  };

  Persistent<FunctionTemplate> IVpnNamespaceInfoFactory::s_constructorTemplate;

  v8::Local<v8::Value> WrapIVpnNamespaceInfoFactory(::Windows::Networking::Vpn::IVpnNamespaceInfoFactory^ 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>(IVpnNamespaceInfoFactory::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::IVpnNamespaceInfoFactory^ UnwrapIVpnNamespaceInfoFactory(Local<Value> value) {
     return IVpnNamespaceInfoFactory::Unwrap<IVpnNamespaceInfoFactory>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIVpnNamespaceInfoFactory(Local<Object> exports) {
    IVpnNamespaceInfoFactory::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("webProxyServers").ToLocalChecked(), WebProxyServersGetter, WebProxyServersSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("namespace").ToLocalChecked(), NamespaceGetter, NamespaceSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dnsServers").ToLocalChecked(), DnsServersGetter, DnsServersSetter);

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



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

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

    private:

      VpnNamespaceInfo(::Windows::Networking::Vpn::VpnNamespaceInfo^ 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::Networking::Vpn::VpnNamespaceInfo^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNamespaceInfo^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::Vpn::VpnNamespaceInfo^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && info[0]->IsString()
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IVector<::Windows::Networking::HostName^>^>(info[1]) || info[1]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IVector<::Windows::Networking::HostName^>^>(info[2]) || info[2]->IsArray()))
      {
        try {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Foundation::Collections::IVector<::Windows::Networking::HostName^>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IVector<::Windows::Networking::HostName^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Networking::HostName^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::HostName^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Networking::HostName^ {
                   return dynamic_cast<::Windows::Networking::HostName^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IVector<::Windows::Networking::HostName^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          ::Windows::Foundation::Collections::IVector<::Windows::Networking::HostName^>^ arg2 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IVector<::Windows::Networking::HostName^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Networking::HostName^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::HostName^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Networking::HostName^ {
                   return dynamic_cast<::Windows::Networking::HostName^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IVector<::Windows::Networking::HostName^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[2]);
          
          winRtInstance = ref new ::Windows::Networking::Vpn::VpnNamespaceInfo(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());

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNamespaceInfo^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::Networking::HostName^>^ result = wrapper->_instance->WebProxyServers;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Networking::HostName^>::CreateVectorWrapper(result, 
            [](::Windows::Networking::HostName^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.Networking", "HostName", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::HostName^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::HostName^ {
              return dynamic_cast<::Windows::Networking::HostName^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void WebProxyServersSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!(NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IVector<::Windows::Networking::HostName^>^>(value) || value->IsArray())) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNamespaceInfo^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Foundation::Collections::IVector<::Windows::Networking::HostName^>^ winRtValue = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IVector<::Windows::Networking::HostName^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Networking::HostName^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::HostName^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Networking::HostName^ {
                   return dynamic_cast<::Windows::Networking::HostName^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IVector<::Windows::Networking::HostName^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (value);

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNamespaceInfo^>(info.This())) {
        return;
      }

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

      try  {
        Platform::String^ result = wrapper->_instance->Namespace;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void NamespaceSetter(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::Networking::Vpn::VpnNamespaceInfo^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNamespaceInfo^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::Networking::HostName^>^ result = wrapper->_instance->DnsServers;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Networking::HostName^>::CreateVectorWrapper(result, 
            [](::Windows::Networking::HostName^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.Networking", "HostName", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::HostName^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::HostName^ {
              return dynamic_cast<::Windows::Networking::HostName^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DnsServersSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!(NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IVector<::Windows::Networking::HostName^>^>(value) || value->IsArray())) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNamespaceInfo^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Foundation::Collections::IVector<::Windows::Networking::HostName^>^ winRtValue = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IVector<::Windows::Networking::HostName^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Networking::HostName^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::HostName^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Networking::HostName^ {
                   return dynamic_cast<::Windows::Networking::HostName^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IVector<::Windows::Networking::HostName^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (value);

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


    private:
      ::Windows::Networking::Vpn::VpnNamespaceInfo^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnNamespaceInfo(::Windows::Networking::Vpn::VpnNamespaceInfo^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnNamespaceInfo^ UnwrapVpnNamespaceInfo(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnNamespaceInfo::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnNamespaceInfo(::Windows::Networking::Vpn::VpnNamespaceInfo^ 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>(VpnNamespaceInfo::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnNamespaceInfo^ UnwrapVpnNamespaceInfo(Local<Value> value) {
     return VpnNamespaceInfo::Unwrap<VpnNamespaceInfo>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnNamespaceInfo(Local<Object> exports) {
    VpnNamespaceInfo::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "createVpnInterfaceId", CreateVpnInterfaceId);
          




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



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

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

    private:

      IVpnInterfaceIdFactory(::Windows::Networking::Vpn::IVpnInterfaceIdFactory^ 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::Networking::Vpn::IVpnInterfaceIdFactory^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnInterfaceIdFactory^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<unsigned char>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Platform::Array<unsigned char>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<unsigned char>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<unsigned char>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsInt32();
                 },
                 [](Local<Value> value) -> unsigned char {
                   return static_cast<unsigned char>(Nan::To<int32_t>(value).FromMaybe(0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<unsigned char>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          ::Windows::Networking::Vpn::VpnInterfaceId^ result;
          result = wrapper->_instance->CreateVpnInterfaceId(arg0);
          info.GetReturnValue().Set(WrapVpnInterfaceId(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





    private:
      ::Windows::Networking::Vpn::IVpnInterfaceIdFactory^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIVpnInterfaceIdFactory(::Windows::Networking::Vpn::IVpnInterfaceIdFactory^ wintRtInstance);
      friend ::Windows::Networking::Vpn::IVpnInterfaceIdFactory^ UnwrapIVpnInterfaceIdFactory(Local<Value> value);
  };

  Persistent<FunctionTemplate> IVpnInterfaceIdFactory::s_constructorTemplate;

  v8::Local<v8::Value> WrapIVpnInterfaceIdFactory(::Windows::Networking::Vpn::IVpnInterfaceIdFactory^ 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>(IVpnInterfaceIdFactory::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::IVpnInterfaceIdFactory^ UnwrapIVpnInterfaceIdFactory(Local<Value> value) {
     return IVpnInterfaceIdFactory::Unwrap<IVpnInterfaceIdFactory>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIVpnInterfaceIdFactory(Local<Object> exports) {
    IVpnInterfaceIdFactory::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getAddressInfo", GetAddressInfo);
          




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



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

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

    private:

      VpnInterfaceId(::Windows::Networking::Vpn::VpnInterfaceId^ 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::Networking::Vpn::VpnInterfaceId^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnInterfaceId^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::Vpn::VpnInterfaceId^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Platform::Array<unsigned char>^>(info[0]) || info[0]->IsArray()))
      {
        try {
          ::Platform::Array<unsigned char>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Platform::Array<unsigned char>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtArray<unsigned char>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsInt32();
                 },
                 [](Local<Value> value) -> unsigned char {
                   return static_cast<unsigned char>(Nan::To<int32_t>(value).FromMaybe(0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Platform::Array<unsigned char>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          winRtInstance = ref new ::Windows::Networking::Vpn::VpnInterfaceId(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());

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnInterfaceId^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Platform::Array<unsigned char>^ arg0;
          
          wrapper->_instance->GetAddressInfo(&arg0);
          Local<Object> resObj = Nan::New<Object>();
          Nan::Set(resObj, Nan::New<String>("id").ToLocalChecked(), NodeRT::Collections::ArrayWrapper<unsigned char>::CreateArrayWrapper(arg0, 
            [](unsigned char val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsInt32();
            },
            [](Local<Value> value) -> unsigned char {
              return static_cast<unsigned char>(Nan::To<int32_t>(value).FromMaybe(0));
            }
          ));
          info.GetReturnValue().Set(resObj);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





    private:
      ::Windows::Networking::Vpn::VpnInterfaceId^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnInterfaceId(::Windows::Networking::Vpn::VpnInterfaceId^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnInterfaceId^ UnwrapVpnInterfaceId(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnInterfaceId::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnInterfaceId(::Windows::Networking::Vpn::VpnInterfaceId^ 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>(VpnInterfaceId::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnInterfaceId^ UnwrapVpnInterfaceId(Local<Value> value) {
     return VpnInterfaceId::Unwrap<VpnInterfaceId>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnInterfaceId(Local<Object> exports) {
    VpnInterfaceId::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("additionalPin").ToLocalChecked(), AdditionalPinGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("certificateCredential").ToLocalChecked(), CertificateCredentialGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("oldPasswordCredential").ToLocalChecked(), OldPasswordCredentialGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("passkeyCredential").ToLocalChecked(), PasskeyCredentialGetter);

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



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

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

    private:

      IVpnCredential(::Windows::Networking::Vpn::IVpnCredential^ 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::Networking::Vpn::IVpnCredential^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnCredential^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnCredential^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnCredential^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnCredential^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Networking::Vpn::IVpnCredential^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIVpnCredential(::Windows::Networking::Vpn::IVpnCredential^ wintRtInstance);
      friend ::Windows::Networking::Vpn::IVpnCredential^ UnwrapIVpnCredential(Local<Value> value);
  };

  Persistent<FunctionTemplate> IVpnCredential::s_constructorTemplate;

  v8::Local<v8::Value> WrapIVpnCredential(::Windows::Networking::Vpn::IVpnCredential^ 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>(IVpnCredential::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::IVpnCredential^ UnwrapIVpnCredential(Local<Value> value) {
     return IVpnCredential::Unwrap<IVpnCredential>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIVpnCredential(Local<Object> exports) {
    IVpnCredential::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("ipv6InclusionRoutes").ToLocalChecked(), Ipv6InclusionRoutesGetter, Ipv6InclusionRoutesSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("ipv6ExclusionRoutes").ToLocalChecked(), Ipv6ExclusionRoutesGetter, Ipv6ExclusionRoutesSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("ipv4InclusionRoutes").ToLocalChecked(), Ipv4InclusionRoutesGetter, Ipv4InclusionRoutesSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("ipv4ExclusionRoutes").ToLocalChecked(), Ipv4ExclusionRoutesGetter, Ipv4ExclusionRoutesSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("excludeLocalSubnets").ToLocalChecked(), ExcludeLocalSubnetsGetter, ExcludeLocalSubnetsSetter);

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



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

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

    private:

      VpnRouteAssignment(::Windows::Networking::Vpn::VpnRouteAssignment^ 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::Networking::Vpn::VpnRouteAssignment^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnRouteAssignment^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnRoute^>^ result = wrapper->_instance->Ipv6InclusionRoutes;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Networking::Vpn::VpnRoute^>::CreateVectorWrapper(result, 
            [](::Windows::Networking::Vpn::VpnRoute^ val) -> Local<Value> {
              return WrapVpnRoute(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnRoute^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::Vpn::VpnRoute^ {
              return UnwrapVpnRoute(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void Ipv6InclusionRoutesSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!(NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnRoute^>^>(value) || value->IsArray())) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnRouteAssignment^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnRoute^>^ winRtValue = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnRoute^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Networking::Vpn::VpnRoute^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnRoute^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Networking::Vpn::VpnRoute^ {
                   return UnwrapVpnRoute(value);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnRoute^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (value);

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnRouteAssignment^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnRoute^>^ result = wrapper->_instance->Ipv6ExclusionRoutes;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Networking::Vpn::VpnRoute^>::CreateVectorWrapper(result, 
            [](::Windows::Networking::Vpn::VpnRoute^ val) -> Local<Value> {
              return WrapVpnRoute(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnRoute^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::Vpn::VpnRoute^ {
              return UnwrapVpnRoute(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void Ipv6ExclusionRoutesSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!(NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnRoute^>^>(value) || value->IsArray())) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnRouteAssignment^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnRoute^>^ winRtValue = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnRoute^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Networking::Vpn::VpnRoute^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnRoute^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Networking::Vpn::VpnRoute^ {
                   return UnwrapVpnRoute(value);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnRoute^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (value);

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnRouteAssignment^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnRoute^>^ result = wrapper->_instance->Ipv4InclusionRoutes;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Networking::Vpn::VpnRoute^>::CreateVectorWrapper(result, 
            [](::Windows::Networking::Vpn::VpnRoute^ val) -> Local<Value> {
              return WrapVpnRoute(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnRoute^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::Vpn::VpnRoute^ {
              return UnwrapVpnRoute(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void Ipv4InclusionRoutesSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!(NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnRoute^>^>(value) || value->IsArray())) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnRouteAssignment^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnRoute^>^ winRtValue = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnRoute^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Networking::Vpn::VpnRoute^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnRoute^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Networking::Vpn::VpnRoute^ {
                   return UnwrapVpnRoute(value);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnRoute^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (value);

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnRouteAssignment^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnRoute^>^ result = wrapper->_instance->Ipv4ExclusionRoutes;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Networking::Vpn::VpnRoute^>::CreateVectorWrapper(result, 
            [](::Windows::Networking::Vpn::VpnRoute^ val) -> Local<Value> {
              return WrapVpnRoute(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnRoute^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::Vpn::VpnRoute^ {
              return UnwrapVpnRoute(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void Ipv4ExclusionRoutesSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!(NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnRoute^>^>(value) || value->IsArray())) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnRouteAssignment^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnRoute^>^ winRtValue = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnRoute^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Networking::Vpn::VpnRoute^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnRoute^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Networking::Vpn::VpnRoute^ {
                   return UnwrapVpnRoute(value);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnRoute^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (value);

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnRouteAssignment^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->ExcludeLocalSubnets;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ExcludeLocalSubnetsSetter(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::Networking::Vpn::VpnRouteAssignment^>(info.This())) {
        return;
      }

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

      try {

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

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


    private:
      ::Windows::Networking::Vpn::VpnRouteAssignment^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnRouteAssignment(::Windows::Networking::Vpn::VpnRouteAssignment^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnRouteAssignment^ UnwrapVpnRouteAssignment(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnRouteAssignment::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnRouteAssignment(::Windows::Networking::Vpn::VpnRouteAssignment^ 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>(VpnRouteAssignment::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnRouteAssignment^ UnwrapVpnRouteAssignment(Local<Value> value) {
     return VpnRouteAssignment::Unwrap<VpnRouteAssignment>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnRouteAssignment(Local<Object> exports) {
    VpnRouteAssignment::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("proxyAutoConfigUri").ToLocalChecked(), ProxyAutoConfigUriGetter, ProxyAutoConfigUriSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("namespaceList").ToLocalChecked(), NamespaceListGetter, NamespaceListSetter);

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



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

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

    private:

      VpnNamespaceAssignment(::Windows::Networking::Vpn::VpnNamespaceAssignment^ 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::Networking::Vpn::VpnNamespaceAssignment^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNamespaceAssignment^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Uri^ result = wrapper->_instance->ProxyAutoConfigUri;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "Uri", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ProxyAutoConfigUriSetter(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::Networking::Vpn::VpnNamespaceAssignment^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNamespaceAssignment^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnNamespaceInfo^>^ result = wrapper->_instance->NamespaceList;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Networking::Vpn::VpnNamespaceInfo^>::CreateVectorWrapper(result, 
            [](::Windows::Networking::Vpn::VpnNamespaceInfo^ val) -> Local<Value> {
              return WrapVpnNamespaceInfo(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNamespaceInfo^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::Vpn::VpnNamespaceInfo^ {
              return UnwrapVpnNamespaceInfo(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void NamespaceListSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!(NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnNamespaceInfo^>^>(value) || value->IsArray())) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNamespaceAssignment^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnNamespaceInfo^>^ winRtValue = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnNamespaceInfo^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Networking::Vpn::VpnNamespaceInfo^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNamespaceInfo^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Networking::Vpn::VpnNamespaceInfo^ {
                   return UnwrapVpnNamespaceInfo(value);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnNamespaceInfo^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (value);

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


    private:
      ::Windows::Networking::Vpn::VpnNamespaceAssignment^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnNamespaceAssignment(::Windows::Networking::Vpn::VpnNamespaceAssignment^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnNamespaceAssignment^ UnwrapVpnNamespaceAssignment(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnNamespaceAssignment::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnNamespaceAssignment(::Windows::Networking::Vpn::VpnNamespaceAssignment^ 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>(VpnNamespaceAssignment::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnNamespaceAssignment^ UnwrapVpnNamespaceAssignment(Local<Value> value) {
     return VpnNamespaceAssignment::Unwrap<VpnNamespaceAssignment>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnNamespaceAssignment(Local<Object> exports) {
    VpnNamespaceAssignment::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("additionalPin").ToLocalChecked(), AdditionalPinGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("oldPasswordCredential").ToLocalChecked(), OldPasswordCredentialGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("passkeyCredential").ToLocalChecked(), PasskeyCredentialGetter);

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



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

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

    private:

      VpnPickedCredential(::Windows::Networking::Vpn::VpnPickedCredential^ 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::Networking::Vpn::VpnPickedCredential^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPickedCredential^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPickedCredential^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPickedCredential^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Networking::Vpn::VpnPickedCredential^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnPickedCredential(::Windows::Networking::Vpn::VpnPickedCredential^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnPickedCredential^ UnwrapVpnPickedCredential(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnPickedCredential::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnPickedCredential(::Windows::Networking::Vpn::VpnPickedCredential^ 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>(VpnPickedCredential::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnPickedCredential^ UnwrapVpnPickedCredential(Local<Value> value) {
     return VpnPickedCredential::Unwrap<VpnPickedCredential>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnPickedCredential(Local<Object> exports) {
    VpnPickedCredential::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("transportAffinity").ToLocalChecked(), TransportAffinityGetter, TransportAffinitySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("status").ToLocalChecked(), StatusGetter, StatusSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("buffer").ToLocalChecked(), BufferGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("appId").ToLocalChecked(), AppIdGetter);

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



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

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

    private:

      VpnPacketBuffer(::Windows::Networking::Vpn::VpnPacketBuffer^ 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::Networking::Vpn::VpnPacketBuffer^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPacketBuffer^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::Vpn::VpnPacketBuffer^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPacketBuffer^>(info[0])
        && info[1]->IsUint32()
        && info[2]->IsUint32())
      {
        try {
          ::Windows::Networking::Vpn::VpnPacketBuffer^ arg0 = UnwrapVpnPacketBuffer(info[0]);
          unsigned int arg1 = static_cast<unsigned int>(Nan::To<uint32_t>(info[1]).FromMaybe(0));
          unsigned int arg2 = static_cast<unsigned int>(Nan::To<uint32_t>(info[2]).FromMaybe(0));
          
          winRtInstance = ref new ::Windows::Networking::Vpn::VpnPacketBuffer(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());

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPacketBuffer^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPacketBuffer^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPacketBuffer^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPacketBuffer^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Networking::Vpn::VpnPacketBufferStatus winRtValue = static_cast<::Windows::Networking::Vpn::VpnPacketBufferStatus>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPacketBuffer^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Storage::Streams::Buffer^ result = wrapper->_instance->Buffer;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Storage.Streams", "Buffer", result));
        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::Networking::Vpn::VpnPacketBuffer^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Networking::Vpn::VpnAppId^ result = wrapper->_instance->AppId;
        info.GetReturnValue().Set(WrapVpnAppId(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::Vpn::VpnPacketBuffer^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnPacketBuffer(::Windows::Networking::Vpn::VpnPacketBuffer^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnPacketBuffer^ UnwrapVpnPacketBuffer(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnPacketBuffer::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnPacketBuffer(::Windows::Networking::Vpn::VpnPacketBuffer^ 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>(VpnPacketBuffer::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnPacketBuffer^ UnwrapVpnPacketBuffer(Local<Value> value) {
     return VpnPacketBuffer::Unwrap<VpnPacketBuffer>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnPacketBuffer(Local<Object> exports) {
    VpnPacketBuffer::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("customField").ToLocalChecked(), CustomFieldGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("serverHostNameList").ToLocalChecked(), ServerHostNameListGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("serverServiceName").ToLocalChecked(), ServerServiceNameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("serverUris").ToLocalChecked(), ServerUrisGetter);

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



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

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

    private:

      VpnChannelConfiguration(::Windows::Networking::Vpn::VpnChannelConfiguration^ 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::Networking::Vpn::VpnChannelConfiguration^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannelConfiguration^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannelConfiguration^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannelConfiguration^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannelConfiguration^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Networking::Vpn::VpnChannelConfiguration^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnChannelConfiguration(::Windows::Networking::Vpn::VpnChannelConfiguration^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnChannelConfiguration^ UnwrapVpnChannelConfiguration(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnChannelConfiguration::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnChannelConfiguration(::Windows::Networking::Vpn::VpnChannelConfiguration^ 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>(VpnChannelConfiguration::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnChannelConfiguration^ UnwrapVpnChannelConfiguration(Local<Value> value) {
     return VpnChannelConfiguration::Unwrap<VpnChannelConfiguration>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnChannelConfiguration(Local<Object> exports) {
    VpnChannelConfiguration::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "associateTransport", AssociateTransport);
            Nan::SetPrototypeMethod(localRef, "start", Start);
            Nan::SetPrototypeMethod(localRef, "stop", Stop);
            Nan::SetPrototypeMethod(localRef, "requestCredentials", RequestCredentials);
            Nan::SetPrototypeMethod(localRef, "requestVpnPacketBuffer", RequestVpnPacketBuffer);
            Nan::SetPrototypeMethod(localRef, "logDiagnosticMessage", LogDiagnosticMessage);
            Nan::SetPrototypeMethod(localRef, "requestCustomPrompt", RequestCustomPrompt);
            Nan::SetPrototypeMethod(localRef, "setErrorMessage", SetErrorMessage);
            Nan::SetPrototypeMethod(localRef, "setAllowedSslTlsVersions", SetAllowedSslTlsVersions);
            Nan::SetPrototypeMethod(localRef, "startWithMainTransport", StartWithMainTransport);
            Nan::SetPrototypeMethod(localRef, "startExistingTransports", StartExistingTransports);
            Nan::SetPrototypeMethod(localRef, "getVpnSendPacketBuffer", GetVpnSendPacketBuffer);
            Nan::SetPrototypeMethod(localRef, "getVpnReceivePacketBuffer", GetVpnReceivePacketBuffer);
            Nan::SetPrototypeMethod(localRef, "terminateConnection", TerminateConnection);
            Nan::SetPrototypeMethod(localRef, "startWithTrafficFilter", StartWithTrafficFilter);
          

          
            Nan::SetPrototypeMethod(localRef, "requestCustomPromptAsync", RequestCustomPromptAsync);
            Nan::SetPrototypeMethod(localRef, "requestCredentialsAsync", RequestCredentialsAsync);
          

          
          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>("plugInContext").ToLocalChecked(), PlugInContextGetter, PlugInContextSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("configuration").ToLocalChecked(), ConfigurationGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("id").ToLocalChecked(), IdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("systemHealth").ToLocalChecked(), SystemHealthGetter);

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

        Nan::SetMethod(constructor, "processEventAsync", ProcessEventAsync);


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

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

    private:

      VpnChannel(::Windows::Networking::Vpn::VpnChannel^ 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::Networking::Vpn::VpnChannel^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(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;
      }

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

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


      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IVectorView<::Windows::Networking::Vpn::IVpnCustomPromptElement^>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::Vpn::IVpnCustomPromptElement^>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::Vpn::IVpnCustomPromptElement^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVectorView<::Windows::Networking::Vpn::IVpnCustomPromptElement^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnCustomPromptElement^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Networking::Vpn::IVpnCustomPromptElement^ {
                   return UnwrapIVpnCustomPromptElement(value);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IVectorView<::Windows::Networking::Vpn::IVpnCustomPromptElement^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          op = wrapper->_instance->RequestCustomPromptAsync(arg0);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::Vpn::VpnCredential^>^ op;


      if (info.Length() == 4
        && info[0]->IsInt32()
        && info[1]->IsUint32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Security::Cryptography::Certificates::Certificate^>(info[2]))
      {
        try
        {
          ::Windows::Networking::Vpn::VpnCredentialType arg0 = static_cast<::Windows::Networking::Vpn::VpnCredentialType>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          unsigned int arg1 = static_cast<unsigned int>(Nan::To<uint32_t>(info[1]).FromMaybe(0));
          ::Windows::Security::Cryptography::Certificates::Certificate^ arg2 = dynamic_cast<::Windows::Security::Cryptography::Certificates::Certificate^>(NodeRT::Utils::GetObjectInstance(info[2]));
          
          op = wrapper->_instance->RequestCredentialsAsync(arg0,arg1,arg2);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && info[0]->IsInt32()
        && info[1]->IsUint32())
      {
        try
        {
          ::Windows::Networking::Vpn::VpnCredentialType arg0 = static_cast<::Windows::Networking::Vpn::VpnCredentialType>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          unsigned int arg1 = static_cast<unsigned int>(Nan::To<uint32_t>(info[1]).FromMaybe(0));
          
          op = wrapper->_instance->RequestCredentialsAsync(arg0,arg1);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::Networking::Vpn::VpnCredentialType arg0 = static_cast<::Windows::Networking::Vpn::VpnCredentialType>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          op = wrapper->_instance->RequestCredentialsAsync(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::Networking::Vpn::VpnCredential^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(info.This())) {
        return;
      }

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

      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[1]))
      {
        try
        {
          ::Platform::Object^ arg0 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Platform::Object^ arg1 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          wrapper->_instance->AssociateTransport(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Start(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(info.This())) {
        return;
      }

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

      if (info.Length() == 10
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^>(info[1]) || info[1]->IsArray())
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnInterfaceId^>(info[2])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnRouteAssignment^>(info[3])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNamespaceAssignment^>(info[4])
        && info[5]->IsUint32()
        && info[6]->IsUint32()
        && info[7]->IsBoolean()
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[8])
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[9]))
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVectorView<::Windows::Networking::HostName^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::HostName^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Networking::HostName^ {
                   return dynamic_cast<::Windows::Networking::HostName^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVectorView<::Windows::Networking::HostName^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::HostName^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Networking::HostName^ {
                   return dynamic_cast<::Windows::Networking::HostName^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          ::Windows::Networking::Vpn::VpnInterfaceId^ arg2 = UnwrapVpnInterfaceId(info[2]);
          ::Windows::Networking::Vpn::VpnRouteAssignment^ arg3 = UnwrapVpnRouteAssignment(info[3]);
          ::Windows::Networking::Vpn::VpnNamespaceAssignment^ arg4 = UnwrapVpnNamespaceAssignment(info[4]);
          unsigned int arg5 = static_cast<unsigned int>(Nan::To<uint32_t>(info[5]).FromMaybe(0));
          unsigned int arg6 = static_cast<unsigned int>(Nan::To<uint32_t>(info[6]).FromMaybe(0));
          bool arg7 = Nan::To<bool>(info[7]).FromMaybe(false);
          ::Platform::Object^ arg8 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[8]));
          ::Platform::Object^ arg9 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[9]));
          
          wrapper->_instance->Start(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
          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::Networking::Vpn::VpnChannel^>(info.This())) {
        return;
      }

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(info.This())) {
        return;
      }

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

      if (info.Length() == 4
        && info[0]->IsInt32()
        && info[1]->IsBoolean()
        && info[2]->IsBoolean()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Security::Cryptography::Certificates::Certificate^>(info[3]))
      {
        try
        {
          ::Windows::Networking::Vpn::VpnCredentialType arg0 = static_cast<::Windows::Networking::Vpn::VpnCredentialType>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          bool arg1 = Nan::To<bool>(info[1]).FromMaybe(false);
          bool arg2 = Nan::To<bool>(info[2]).FromMaybe(false);
          ::Windows::Security::Cryptography::Certificates::Certificate^ arg3 = dynamic_cast<::Windows::Security::Cryptography::Certificates::Certificate^>(NodeRT::Utils::GetObjectInstance(info[3]));
          
          ::Windows::Networking::Vpn::VpnPickedCredential^ result;
          result = wrapper->_instance->RequestCredentials(arg0, arg1, arg2, arg3);
          info.GetReturnValue().Set(WrapVpnPickedCredential(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 RequestVpnPacketBuffer(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::Networking::Vpn::VpnDataPathType arg0 = static_cast<::Windows::Networking::Vpn::VpnDataPathType>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          ::Windows::Networking::Vpn::VpnPacketBuffer^ arg1;
          
          wrapper->_instance->RequestVpnPacketBuffer(arg0, &arg1);
          Local<Object> resObj = Nan::New<Object>();
          Nan::Set(resObj, Nan::New<String>("vpnPacketBuffer").ToLocalChecked(), NodeRT::Utils::CreateExternalWinRTObject("Windows.Networking.Vpn", "VpnPacketBuffer", arg1));
          info.GetReturnValue().Set(resObj);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void LogDiagnosticMessage(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          wrapper->_instance->LogDiagnosticMessage(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 RequestCustomPrompt(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IVectorView<::Windows::Networking::Vpn::IVpnCustomPrompt^>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::Vpn::IVpnCustomPrompt^>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::Vpn::IVpnCustomPrompt^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVectorView<::Windows::Networking::Vpn::IVpnCustomPrompt^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnCustomPrompt^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Networking::Vpn::IVpnCustomPrompt^ {
                   return UnwrapIVpnCustomPrompt(value);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IVectorView<::Windows::Networking::Vpn::IVpnCustomPrompt^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          wrapper->_instance->RequestCustomPrompt(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 SetErrorMessage(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          wrapper->_instance->SetErrorMessage(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 SetAllowedSslTlsVersions(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(info.This())) {
        return;
      }

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

      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[0])
        && info[1]->IsBoolean())
      {
        try
        {
          ::Platform::Object^ arg0 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[0]));
          bool arg1 = Nan::To<bool>(info[1]).FromMaybe(false);
          
          wrapper->_instance->SetAllowedSslTlsVersions(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void StartWithMainTransport(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(info.This())) {
        return;
      }

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

      if (info.Length() == 9
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^>(info[1]) || info[1]->IsArray())
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnInterfaceId^>(info[2])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnRouteAssignment^>(info[3])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnDomainNameAssignment^>(info[4])
        && info[5]->IsUint32()
        && info[6]->IsUint32()
        && info[7]->IsBoolean()
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[8]))
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVectorView<::Windows::Networking::HostName^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::HostName^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Networking::HostName^ {
                   return dynamic_cast<::Windows::Networking::HostName^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVectorView<::Windows::Networking::HostName^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::HostName^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Networking::HostName^ {
                   return dynamic_cast<::Windows::Networking::HostName^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          ::Windows::Networking::Vpn::VpnInterfaceId^ arg2 = UnwrapVpnInterfaceId(info[2]);
          ::Windows::Networking::Vpn::VpnRouteAssignment^ arg3 = UnwrapVpnRouteAssignment(info[3]);
          ::Windows::Networking::Vpn::VpnDomainNameAssignment^ arg4 = UnwrapVpnDomainNameAssignment(info[4]);
          unsigned int arg5 = static_cast<unsigned int>(Nan::To<uint32_t>(info[5]).FromMaybe(0));
          unsigned int arg6 = static_cast<unsigned int>(Nan::To<uint32_t>(info[6]).FromMaybe(0));
          bool arg7 = Nan::To<bool>(info[7]).FromMaybe(false);
          ::Platform::Object^ arg8 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[8]));
          
          wrapper->_instance->StartWithMainTransport(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
          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 StartExistingTransports(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(info.This())) {
        return;
      }

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

      if (info.Length() == 8
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^>(info[1]) || info[1]->IsArray())
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnInterfaceId^>(info[2])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnRouteAssignment^>(info[3])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnDomainNameAssignment^>(info[4])
        && info[5]->IsUint32()
        && info[6]->IsUint32()
        && info[7]->IsBoolean())
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVectorView<::Windows::Networking::HostName^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::HostName^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Networking::HostName^ {
                   return dynamic_cast<::Windows::Networking::HostName^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVectorView<::Windows::Networking::HostName^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::HostName^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Networking::HostName^ {
                   return dynamic_cast<::Windows::Networking::HostName^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          ::Windows::Networking::Vpn::VpnInterfaceId^ arg2 = UnwrapVpnInterfaceId(info[2]);
          ::Windows::Networking::Vpn::VpnRouteAssignment^ arg3 = UnwrapVpnRouteAssignment(info[3]);
          ::Windows::Networking::Vpn::VpnDomainNameAssignment^ arg4 = UnwrapVpnDomainNameAssignment(info[4]);
          unsigned int arg5 = static_cast<unsigned int>(Nan::To<uint32_t>(info[5]).FromMaybe(0));
          unsigned int arg6 = static_cast<unsigned int>(Nan::To<uint32_t>(info[6]).FromMaybe(0));
          bool arg7 = Nan::To<bool>(info[7]).FromMaybe(false);
          
          wrapper->_instance->StartExistingTransports(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
          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 GetVpnSendPacketBuffer(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Networking::Vpn::VpnPacketBuffer^ result;
          result = wrapper->_instance->GetVpnSendPacketBuffer();
          info.GetReturnValue().Set(WrapVpnPacketBuffer(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 GetVpnReceivePacketBuffer(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Networking::Vpn::VpnPacketBuffer^ result;
          result = wrapper->_instance->GetVpnReceivePacketBuffer();
          info.GetReturnValue().Set(WrapVpnPacketBuffer(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 TerminateConnection(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          wrapper->_instance->TerminateConnection(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 StartWithTrafficFilter(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(info.This())) {
        return;
      }

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

      if (info.Length() == 11
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^>(info[0]) || info[0]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^>(info[1]) || info[1]->IsArray())
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnInterfaceId^>(info[2])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnRouteAssignment^>(info[3])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnDomainNameAssignment^>(info[4])
        && info[5]->IsUint32()
        && info[6]->IsUint32()
        && info[7]->IsBoolean()
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[8])
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[9])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnTrafficFilterAssignment^>(info[10]))
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVectorView<::Windows::Networking::HostName^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::HostName^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Networking::HostName^ {
                   return dynamic_cast<::Windows::Networking::HostName^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVectorView<::Windows::Networking::HostName^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::HostName^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Networking::HostName^ {
                   return dynamic_cast<::Windows::Networking::HostName^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          ::Windows::Networking::Vpn::VpnInterfaceId^ arg2 = UnwrapVpnInterfaceId(info[2]);
          ::Windows::Networking::Vpn::VpnRouteAssignment^ arg3 = UnwrapVpnRouteAssignment(info[3]);
          ::Windows::Networking::Vpn::VpnDomainNameAssignment^ arg4 = UnwrapVpnDomainNameAssignment(info[4]);
          unsigned int arg5 = static_cast<unsigned int>(Nan::To<uint32_t>(info[5]).FromMaybe(0));
          unsigned int arg6 = static_cast<unsigned int>(Nan::To<uint32_t>(info[6]).FromMaybe(0));
          bool arg7 = Nan::To<bool>(info[7]).FromMaybe(false);
          ::Platform::Object^ arg8 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[8]));
          ::Platform::Object^ arg9 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[9]));
          ::Windows::Networking::Vpn::VpnTrafficFilterAssignment^ arg10 = UnwrapVpnTrafficFilterAssignment(info[10]);
          
          wrapper->_instance->StartWithTrafficFilter(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
          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 ProcessEventAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[1]))
      {
        try
        {
          ::Platform::Object^ arg0 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Platform::Object^ arg1 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          ::Windows::Networking::Vpn::VpnChannel::ProcessEventAsync(arg0, arg1);
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::Object^ winRtValue = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(value));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Networking::Vpn::VpnSystemHealth^ result = wrapper->_instance->SystemHealth;
        info.GetReturnValue().Set(WrapVpnSystemHealth(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"activityChange", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(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;
        }
        VpnChannel *wrapper = VpnChannel::Unwrap<VpnChannel>(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->ActivityChange::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Networking::Vpn::VpnChannel^, ::Windows::Networking::Vpn::VpnChannelActivityEventArgs^>(
            [callbackObjPtr](::Windows::Networking::Vpn::VpnChannel^ arg0, ::Windows::Networking::Vpn::VpnChannelActivityEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapVpnChannel(arg0);
                  wrappedArg1 = WrapVpnChannelActivityEventArgs(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"activityStateChange", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(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;
        }
        VpnChannel *wrapper = VpnChannel::Unwrap<VpnChannel>(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->ActivityStateChange::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Networking::Vpn::VpnChannel^, ::Windows::Networking::Vpn::VpnChannelActivityStateChangedArgs^>(
            [callbackObjPtr](::Windows::Networking::Vpn::VpnChannel^ arg0, ::Windows::Networking::Vpn::VpnChannelActivityStateChangedArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapVpnChannel(arg0);
                  wrappedArg1 = WrapVpnChannelActivityStateChangedArgs(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"activityChange", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"activityStateChange", 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"activityChange", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(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;
          }
          VpnChannel *wrapper = VpnChannel::Unwrap<VpnChannel>(info.This());
          wrapper->_instance->ActivityChange::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"activityStateChange", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannel^>(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;
          }
          VpnChannel *wrapper = VpnChannel::Unwrap<VpnChannel>(info.This());
          wrapper->_instance->ActivityStateChange::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::Networking::Vpn::VpnChannel^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnChannel(::Windows::Networking::Vpn::VpnChannel^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnChannel^ UnwrapVpnChannel(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnChannel::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnChannel(::Windows::Networking::Vpn::VpnChannel^ 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>(VpnChannel::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnChannel^ UnwrapVpnChannel(Local<Value> value) {
     return VpnChannel::Unwrap<VpnChannel>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnChannel(Local<Object> exports) {
    VpnChannel::Init(exports);
  }

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





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

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



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

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

    private:

      VpnChannelActivityEventArgs(::Windows::Networking::Vpn::VpnChannelActivityEventArgs^ 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::Networking::Vpn::VpnChannelActivityEventArgs^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannelActivityEventArgs^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Networking::Vpn::VpnChannelActivityEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnChannelActivityEventArgs(::Windows::Networking::Vpn::VpnChannelActivityEventArgs^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnChannelActivityEventArgs^ UnwrapVpnChannelActivityEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnChannelActivityEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnChannelActivityEventArgs(::Windows::Networking::Vpn::VpnChannelActivityEventArgs^ 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>(VpnChannelActivityEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnChannelActivityEventArgs^ UnwrapVpnChannelActivityEventArgs(Local<Value> value) {
     return VpnChannelActivityEventArgs::Unwrap<VpnChannelActivityEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnChannelActivityEventArgs(Local<Object> exports) {
    VpnChannelActivityEventArgs::Init(exports);
  }

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





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

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



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

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

    private:

      VpnSystemHealth(::Windows::Networking::Vpn::VpnSystemHealth^ 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::Networking::Vpn::VpnSystemHealth^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnSystemHealth^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Networking::Vpn::VpnSystemHealth^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnSystemHealth(::Windows::Networking::Vpn::VpnSystemHealth^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnSystemHealth^ UnwrapVpnSystemHealth(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnSystemHealth::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnSystemHealth(::Windows::Networking::Vpn::VpnSystemHealth^ 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>(VpnSystemHealth::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnSystemHealth^ UnwrapVpnSystemHealth(Local<Value> value) {
     return VpnSystemHealth::Unwrap<VpnSystemHealth>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnSystemHealth(Local<Object> exports) {
    VpnSystemHealth::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("proxyAutoConfigurationUri").ToLocalChecked(), ProxyAutoConfigurationUriGetter, ProxyAutoConfigurationUriSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("domainNameList").ToLocalChecked(), DomainNameListGetter);

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



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

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

    private:

      VpnDomainNameAssignment(::Windows::Networking::Vpn::VpnDomainNameAssignment^ 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::Networking::Vpn::VpnDomainNameAssignment^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnDomainNameAssignment^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Uri^ result = wrapper->_instance->ProxyAutoConfigurationUri;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "Uri", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ProxyAutoConfigurationUriSetter(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::Networking::Vpn::VpnDomainNameAssignment^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnDomainNameAssignment^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnDomainNameInfo^>^ result = wrapper->_instance->DomainNameList;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Networking::Vpn::VpnDomainNameInfo^>::CreateVectorWrapper(result, 
            [](::Windows::Networking::Vpn::VpnDomainNameInfo^ val) -> Local<Value> {
              return WrapVpnDomainNameInfo(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnDomainNameInfo^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::Vpn::VpnDomainNameInfo^ {
              return UnwrapVpnDomainNameInfo(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::Vpn::VpnDomainNameAssignment^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnDomainNameAssignment(::Windows::Networking::Vpn::VpnDomainNameAssignment^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnDomainNameAssignment^ UnwrapVpnDomainNameAssignment(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnDomainNameAssignment::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnDomainNameAssignment(::Windows::Networking::Vpn::VpnDomainNameAssignment^ 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>(VpnDomainNameAssignment::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnDomainNameAssignment^ UnwrapVpnDomainNameAssignment(Local<Value> value) {
     return VpnDomainNameAssignment::Unwrap<VpnDomainNameAssignment>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnDomainNameAssignment(Local<Object> exports) {
    VpnDomainNameAssignment::Init(exports);
  }

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





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

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



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

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

    private:

      VpnChannelActivityStateChangedArgs(::Windows::Networking::Vpn::VpnChannelActivityStateChangedArgs^ 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::Networking::Vpn::VpnChannelActivityStateChangedArgs^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnChannelActivityStateChangedArgs^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Networking::Vpn::VpnChannelActivityStateChangedArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnChannelActivityStateChangedArgs(::Windows::Networking::Vpn::VpnChannelActivityStateChangedArgs^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnChannelActivityStateChangedArgs^ UnwrapVpnChannelActivityStateChangedArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnChannelActivityStateChangedArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnChannelActivityStateChangedArgs(::Windows::Networking::Vpn::VpnChannelActivityStateChangedArgs^ 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>(VpnChannelActivityStateChangedArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnChannelActivityStateChangedArgs^ UnwrapVpnChannelActivityStateChangedArgs(Local<Value> value) {
     return VpnChannelActivityStateChangedArgs::Unwrap<VpnChannelActivityStateChangedArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnChannelActivityStateChangedArgs(Local<Object> exports) {
    VpnChannelActivityStateChangedArgs::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("compulsory").ToLocalChecked(), CompulsoryGetter, CompulsorySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("displayName").ToLocalChecked(), DisplayNameGetter, DisplayNameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("emphasized").ToLocalChecked(), EmphasizedGetter, EmphasizedSetter);

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



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

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

    private:

      IVpnCustomPromptElement(::Windows::Networking::Vpn::IVpnCustomPromptElement^ 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::Networking::Vpn::IVpnCustomPromptElement^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnCustomPromptElement^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->Compulsory;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CompulsorySetter(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::Networking::Vpn::IVpnCustomPromptElement^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnCustomPromptElement^>(info.This())) {
        return;
      }

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

      try  {
        Platform::String^ result = wrapper->_instance->DisplayName;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DisplayNameSetter(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::Networking::Vpn::IVpnCustomPromptElement^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnCustomPromptElement^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->Emphasized;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void EmphasizedSetter(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::Networking::Vpn::IVpnCustomPromptElement^>(info.This())) {
        return;
      }

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

      try {

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

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


    private:
      ::Windows::Networking::Vpn::IVpnCustomPromptElement^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIVpnCustomPromptElement(::Windows::Networking::Vpn::IVpnCustomPromptElement^ wintRtInstance);
      friend ::Windows::Networking::Vpn::IVpnCustomPromptElement^ UnwrapIVpnCustomPromptElement(Local<Value> value);
  };

  Persistent<FunctionTemplate> IVpnCustomPromptElement::s_constructorTemplate;

  v8::Local<v8::Value> WrapIVpnCustomPromptElement(::Windows::Networking::Vpn::IVpnCustomPromptElement^ 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>(IVpnCustomPromptElement::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::IVpnCustomPromptElement^ UnwrapIVpnCustomPromptElement(Local<Value> value) {
     return IVpnCustomPromptElement::Unwrap<IVpnCustomPromptElement>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIVpnCustomPromptElement(Local<Object> exports) {
    IVpnCustomPromptElement::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("additionalPin").ToLocalChecked(), AdditionalPinGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("certificateCredential").ToLocalChecked(), CertificateCredentialGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("oldPasswordCredential").ToLocalChecked(), OldPasswordCredentialGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("passkeyCredential").ToLocalChecked(), PasskeyCredentialGetter);

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



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

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

    private:

      VpnCredential(::Windows::Networking::Vpn::VpnCredential^ 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::Networking::Vpn::VpnCredential^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCredential^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCredential^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCredential^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCredential^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Networking::Vpn::VpnCredential^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnCredential(::Windows::Networking::Vpn::VpnCredential^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnCredential^ UnwrapVpnCredential(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnCredential::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnCredential(::Windows::Networking::Vpn::VpnCredential^ 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>(VpnCredential::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnCredential^ UnwrapVpnCredential(Local<Value> value) {
     return VpnCredential::Unwrap<VpnCredential>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnCredential(Local<Object> exports) {
    VpnCredential::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("allowOutbound").ToLocalChecked(), AllowOutboundGetter, AllowOutboundSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("allowInbound").ToLocalChecked(), AllowInboundGetter, AllowInboundSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("trafficFilterList").ToLocalChecked(), TrafficFilterListGetter);

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



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

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

    private:

      VpnTrafficFilterAssignment(::Windows::Networking::Vpn::VpnTrafficFilterAssignment^ 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::Networking::Vpn::VpnTrafficFilterAssignment^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnTrafficFilterAssignment^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->AllowOutbound;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AllowOutboundSetter(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::Networking::Vpn::VpnTrafficFilterAssignment^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnTrafficFilterAssignment^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->AllowInbound;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AllowInboundSetter(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::Networking::Vpn::VpnTrafficFilterAssignment^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnTrafficFilterAssignment^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnTrafficFilter^>^ result = wrapper->_instance->TrafficFilterList;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Networking::Vpn::VpnTrafficFilter^>::CreateVectorWrapper(result, 
            [](::Windows::Networking::Vpn::VpnTrafficFilter^ val) -> Local<Value> {
              return WrapVpnTrafficFilter(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnTrafficFilter^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::Vpn::VpnTrafficFilter^ {
              return UnwrapVpnTrafficFilter(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::Vpn::VpnTrafficFilterAssignment^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnTrafficFilterAssignment(::Windows::Networking::Vpn::VpnTrafficFilterAssignment^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnTrafficFilterAssignment^ UnwrapVpnTrafficFilterAssignment(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnTrafficFilterAssignment::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnTrafficFilterAssignment(::Windows::Networking::Vpn::VpnTrafficFilterAssignment^ 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>(VpnTrafficFilterAssignment::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnTrafficFilterAssignment^ UnwrapVpnTrafficFilterAssignment(Local<Value> value) {
     return VpnTrafficFilterAssignment::Unwrap<VpnTrafficFilterAssignment>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnTrafficFilterAssignment(Local<Object> exports) {
    VpnTrafficFilterAssignment::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "processEventAsync", ProcessEventAsync);
          




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



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

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

    private:

      IVpnChannelStatics(::Windows::Networking::Vpn::IVpnChannelStatics^ 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::Networking::Vpn::IVpnChannelStatics^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnChannelStatics^>(info.This())) {
        return;
      }

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

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





    private:
      ::Windows::Networking::Vpn::IVpnChannelStatics^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIVpnChannelStatics(::Windows::Networking::Vpn::IVpnChannelStatics^ wintRtInstance);
      friend ::Windows::Networking::Vpn::IVpnChannelStatics^ UnwrapIVpnChannelStatics(Local<Value> value);
  };

  Persistent<FunctionTemplate> IVpnChannelStatics::s_constructorTemplate;

  v8::Local<v8::Value> WrapIVpnChannelStatics(::Windows::Networking::Vpn::IVpnChannelStatics^ 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>(IVpnChannelStatics::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::IVpnChannelStatics^ UnwrapIVpnChannelStatics(Local<Value> value) {
     return IVpnChannelStatics::Unwrap<IVpnChannelStatics>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIVpnChannelStatics(Local<Object> exports) {
    IVpnChannelStatics::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "createVpnPacketBuffer", CreateVpnPacketBuffer);
          




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



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

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

    private:

      IVpnPacketBufferFactory(::Windows::Networking::Vpn::IVpnPacketBufferFactory^ 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::Networking::Vpn::IVpnPacketBufferFactory^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnPacketBufferFactory^>(info.This())) {
        return;
      }

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

      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPacketBuffer^>(info[0])
        && info[1]->IsUint32()
        && info[2]->IsUint32())
      {
        try
        {
          ::Windows::Networking::Vpn::VpnPacketBuffer^ arg0 = UnwrapVpnPacketBuffer(info[0]);
          unsigned int arg1 = static_cast<unsigned int>(Nan::To<uint32_t>(info[1]).FromMaybe(0));
          unsigned int arg2 = static_cast<unsigned int>(Nan::To<uint32_t>(info[2]).FromMaybe(0));
          
          ::Windows::Networking::Vpn::VpnPacketBuffer^ result;
          result = wrapper->_instance->CreateVpnPacketBuffer(arg0, arg1, arg2);
          info.GetReturnValue().Set(WrapVpnPacketBuffer(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





    private:
      ::Windows::Networking::Vpn::IVpnPacketBufferFactory^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIVpnPacketBufferFactory(::Windows::Networking::Vpn::IVpnPacketBufferFactory^ wintRtInstance);
      friend ::Windows::Networking::Vpn::IVpnPacketBufferFactory^ UnwrapIVpnPacketBufferFactory(Local<Value> value);
  };

  Persistent<FunctionTemplate> IVpnPacketBufferFactory::s_constructorTemplate;

  v8::Local<v8::Value> WrapIVpnPacketBufferFactory(::Windows::Networking::Vpn::IVpnPacketBufferFactory^ 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>(IVpnPacketBufferFactory::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::IVpnPacketBufferFactory^ UnwrapIVpnPacketBufferFactory(Local<Value> value) {
     return IVpnPacketBufferFactory::Unwrap<IVpnPacketBufferFactory>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIVpnPacketBufferFactory(Local<Object> exports) {
    IVpnPacketBufferFactory::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("value").ToLocalChecked(), ValueGetter, ValueSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("type").ToLocalChecked(), TypeGetter, TypeSetter);

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



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

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

    private:

      VpnAppId(::Windows::Networking::Vpn::VpnAppId^ 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::Networking::Vpn::VpnAppId^ winRtInstance;


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

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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnAppId^>(info.This())) {
        return;
      }

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

      try  {
        Platform::String^ result = wrapper->_instance->Value;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ValueSetter(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::Networking::Vpn::VpnAppId^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnAppId^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnAppId^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Networking::Vpn::VpnAppIdType winRtValue = static_cast<::Windows::Networking::Vpn::VpnAppIdType>(Nan::To<int32_t>(value).FromMaybe(0));

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


    private:
      ::Windows::Networking::Vpn::VpnAppId^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnAppId(::Windows::Networking::Vpn::VpnAppId^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnAppId^ UnwrapVpnAppId(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnAppId::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnAppId(::Windows::Networking::Vpn::VpnAppId^ 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>(VpnAppId::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnAppId^ UnwrapVpnAppId(Local<Value> value) {
     return VpnAppId::Unwrap<VpnAppId>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnAppId(Local<Object> exports) {
    VpnAppId::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "createVpnDomainNameInfo", CreateVpnDomainNameInfo);
          




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



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

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

    private:

      IVpnDomainNameInfoFactory(::Windows::Networking::Vpn::IVpnDomainNameInfoFactory^ 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::Networking::Vpn::IVpnDomainNameInfoFactory^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnDomainNameInfoFactory^>(info.This())) {
        return;
      }

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

      if (info.Length() == 4
        && info[0]->IsString()
        && info[1]->IsInt32()
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Windows::Networking::HostName^>^>(info[2]) || info[2]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Windows::Networking::HostName^>^>(info[3]) || info[3]->IsArray()))
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Networking::Vpn::VpnDomainNameType arg1 = static_cast<::Windows::Networking::Vpn::VpnDomainNameType>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          ::Windows::Foundation::Collections::IIterable<::Windows::Networking::HostName^>^ arg2 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Windows::Networking::HostName^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Networking::HostName^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::HostName^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Networking::HostName^ {
                   return dynamic_cast<::Windows::Networking::HostName^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Windows::Networking::HostName^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[2]);
          ::Windows::Foundation::Collections::IIterable<::Windows::Networking::HostName^>^ arg3 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Windows::Networking::HostName^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Networking::HostName^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::HostName^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Networking::HostName^ {
                   return dynamic_cast<::Windows::Networking::HostName^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Windows::Networking::HostName^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[3]);
          
          ::Windows::Networking::Vpn::VpnDomainNameInfo^ result;
          result = wrapper->_instance->CreateVpnDomainNameInfo(arg0, arg1, arg2, arg3);
          info.GetReturnValue().Set(WrapVpnDomainNameInfo(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





    private:
      ::Windows::Networking::Vpn::IVpnDomainNameInfoFactory^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIVpnDomainNameInfoFactory(::Windows::Networking::Vpn::IVpnDomainNameInfoFactory^ wintRtInstance);
      friend ::Windows::Networking::Vpn::IVpnDomainNameInfoFactory^ UnwrapIVpnDomainNameInfoFactory(Local<Value> value);
  };

  Persistent<FunctionTemplate> IVpnDomainNameInfoFactory::s_constructorTemplate;

  v8::Local<v8::Value> WrapIVpnDomainNameInfoFactory(::Windows::Networking::Vpn::IVpnDomainNameInfoFactory^ 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>(IVpnDomainNameInfoFactory::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::IVpnDomainNameInfoFactory^ UnwrapIVpnDomainNameInfoFactory(Local<Value> value) {
     return IVpnDomainNameInfoFactory::Unwrap<IVpnDomainNameInfoFactory>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIVpnDomainNameInfoFactory(Local<Object> exports) {
    IVpnDomainNameInfoFactory::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("domainNameType").ToLocalChecked(), DomainNameTypeGetter, DomainNameTypeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("domainName").ToLocalChecked(), DomainNameGetter, DomainNameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dnsServers").ToLocalChecked(), DnsServersGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("webProxyServers").ToLocalChecked(), WebProxyServersGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("webProxyUris").ToLocalChecked(), WebProxyUrisGetter);

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



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

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

    private:

      VpnDomainNameInfo(::Windows::Networking::Vpn::VpnDomainNameInfo^ 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::Networking::Vpn::VpnDomainNameInfo^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnDomainNameInfo^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::Vpn::VpnDomainNameInfo^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 4
        && info[0]->IsString()
        && info[1]->IsInt32()
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Windows::Networking::HostName^>^>(info[2]) || info[2]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Windows::Networking::HostName^>^>(info[3]) || info[3]->IsArray()))
      {
        try {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Networking::Vpn::VpnDomainNameType arg1 = static_cast<::Windows::Networking::Vpn::VpnDomainNameType>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          ::Windows::Foundation::Collections::IIterable<::Windows::Networking::HostName^>^ arg2 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Windows::Networking::HostName^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Networking::HostName^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::HostName^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Networking::HostName^ {
                   return dynamic_cast<::Windows::Networking::HostName^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Windows::Networking::HostName^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[2]);
          ::Windows::Foundation::Collections::IIterable<::Windows::Networking::HostName^>^ arg3 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Windows::Networking::HostName^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Networking::HostName^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::HostName^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Networking::HostName^ {
                   return dynamic_cast<::Windows::Networking::HostName^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Windows::Networking::HostName^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[3]);
          
          winRtInstance = ref new ::Windows::Networking::Vpn::VpnDomainNameInfo(arg0,arg1,arg2,arg3);
        } 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());

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnDomainNameInfo^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnDomainNameInfo^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Networking::Vpn::VpnDomainNameType winRtValue = static_cast<::Windows::Networking::Vpn::VpnDomainNameType>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnDomainNameInfo^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnDomainNameInfo^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Networking::HostName^ winRtValue = dynamic_cast<::Windows::Networking::HostName^>(NodeRT::Utils::GetObjectInstance(value));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnDomainNameInfo^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::Networking::HostName^>^ result = wrapper->_instance->DnsServers;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Networking::HostName^>::CreateVectorWrapper(result, 
            [](::Windows::Networking::HostName^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.Networking", "HostName", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::HostName^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::HostName^ {
              return dynamic_cast<::Windows::Networking::HostName^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void WebProxyServersGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnDomainNameInfo^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::Networking::HostName^>^ result = wrapper->_instance->WebProxyServers;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Networking::HostName^>::CreateVectorWrapper(result, 
            [](::Windows::Networking::HostName^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.Networking", "HostName", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::HostName^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::HostName^ {
              return dynamic_cast<::Windows::Networking::HostName^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void WebProxyUrisGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnDomainNameInfo^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::Foundation::Uri^>^ result = wrapper->_instance->WebProxyUris;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Foundation::Uri^>::CreateVectorWrapper(result, 
            [](::Windows::Foundation::Uri^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "Uri", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(value);
            },
            [](Local<Value> value) -> ::Windows::Foundation::Uri^ {
              return dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::Vpn::VpnDomainNameInfo^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnDomainNameInfo(::Windows::Networking::Vpn::VpnDomainNameInfo^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnDomainNameInfo^ UnwrapVpnDomainNameInfo(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnDomainNameInfo::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnDomainNameInfo(::Windows::Networking::Vpn::VpnDomainNameInfo^ 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>(VpnDomainNameInfo::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnDomainNameInfo^ UnwrapVpnDomainNameInfo(Local<Value> value) {
     return VpnDomainNameInfo::Unwrap<VpnDomainNameInfo>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnDomainNameInfo(Local<Object> exports) {
    VpnDomainNameInfo::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("routingPolicyType").ToLocalChecked(), RoutingPolicyTypeGetter, RoutingPolicyTypeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("protocol").ToLocalChecked(), ProtocolGetter, ProtocolSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("appId").ToLocalChecked(), AppIdGetter, AppIdSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("appClaims").ToLocalChecked(), AppClaimsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("localAddressRanges").ToLocalChecked(), LocalAddressRangesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("localPortRanges").ToLocalChecked(), LocalPortRangesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("remoteAddressRanges").ToLocalChecked(), RemoteAddressRangesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("remotePortRanges").ToLocalChecked(), RemotePortRangesGetter);

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



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

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

    private:

      VpnTrafficFilter(::Windows::Networking::Vpn::VpnTrafficFilter^ 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::Networking::Vpn::VpnTrafficFilter^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnTrafficFilter^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnTrafficFilter^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Networking::Vpn::VpnRoutingPolicyType winRtValue = static_cast<::Windows::Networking::Vpn::VpnRoutingPolicyType>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnTrafficFilter^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnTrafficFilter^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Networking::Vpn::VpnIPProtocol winRtValue = static_cast<::Windows::Networking::Vpn::VpnIPProtocol>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->Protocol = 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::Networking::Vpn::VpnTrafficFilter^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Networking::Vpn::VpnAppId^ result = wrapper->_instance->AppId;
        info.GetReturnValue().Set(WrapVpnAppId(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::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnAppId^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnTrafficFilter^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Networking::Vpn::VpnAppId^ winRtValue = dynamic_cast<::Windows::Networking::Vpn::VpnAppId^>(NodeRT::Utils::GetObjectInstance(value));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnTrafficFilter^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnTrafficFilter^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnTrafficFilter^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnTrafficFilter^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnTrafficFilter^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Networking::Vpn::VpnTrafficFilter^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnTrafficFilter(::Windows::Networking::Vpn::VpnTrafficFilter^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnTrafficFilter^ UnwrapVpnTrafficFilter(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnTrafficFilter::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnTrafficFilter(::Windows::Networking::Vpn::VpnTrafficFilter^ 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>(VpnTrafficFilter::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnTrafficFilter^ UnwrapVpnTrafficFilter(Local<Value> value) {
     return VpnTrafficFilter::Unwrap<VpnTrafficFilter>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnTrafficFilter(Local<Object> exports) {
    VpnTrafficFilter::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("alwaysOn").ToLocalChecked(), AlwaysOnGetter, AlwaysOnSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("appTriggers").ToLocalChecked(), AppTriggersGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("domainNameInfoList").ToLocalChecked(), DomainNameInfoListGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("profileName").ToLocalChecked(), ProfileNameGetter, ProfileNameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("rememberCredentials").ToLocalChecked(), RememberCredentialsGetter, RememberCredentialsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("routes").ToLocalChecked(), RoutesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("trafficFilters").ToLocalChecked(), TrafficFiltersGetter);

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



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

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

    private:

      IVpnProfile(::Windows::Networking::Vpn::IVpnProfile^ 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::Networking::Vpn::IVpnProfile^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnProfile^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->AlwaysOn;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AlwaysOnSetter(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::Networking::Vpn::IVpnProfile^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnProfile^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnAppId^>^ result = wrapper->_instance->AppTriggers;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Networking::Vpn::VpnAppId^>::CreateVectorWrapper(result, 
            [](::Windows::Networking::Vpn::VpnAppId^ val) -> Local<Value> {
              return WrapVpnAppId(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnAppId^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::Vpn::VpnAppId^ {
              return UnwrapVpnAppId(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DomainNameInfoListGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnProfile^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnDomainNameInfo^>^ result = wrapper->_instance->DomainNameInfoList;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Networking::Vpn::VpnDomainNameInfo^>::CreateVectorWrapper(result, 
            [](::Windows::Networking::Vpn::VpnDomainNameInfo^ val) -> Local<Value> {
              return WrapVpnDomainNameInfo(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnDomainNameInfo^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::Vpn::VpnDomainNameInfo^ {
              return UnwrapVpnDomainNameInfo(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ProfileNameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnProfile^>(info.This())) {
        return;
      }

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

      try  {
        Platform::String^ result = wrapper->_instance->ProfileName;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ProfileNameSetter(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::Networking::Vpn::IVpnProfile^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnProfile^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->RememberCredentials;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RememberCredentialsSetter(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::Networking::Vpn::IVpnProfile^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnProfile^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnRoute^>^ result = wrapper->_instance->Routes;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Networking::Vpn::VpnRoute^>::CreateVectorWrapper(result, 
            [](::Windows::Networking::Vpn::VpnRoute^ val) -> Local<Value> {
              return WrapVpnRoute(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnRoute^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::Vpn::VpnRoute^ {
              return UnwrapVpnRoute(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TrafficFiltersGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnProfile^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnTrafficFilter^>^ result = wrapper->_instance->TrafficFilters;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Networking::Vpn::VpnTrafficFilter^>::CreateVectorWrapper(result, 
            [](::Windows::Networking::Vpn::VpnTrafficFilter^ val) -> Local<Value> {
              return WrapVpnTrafficFilter(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnTrafficFilter^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::Vpn::VpnTrafficFilter^ {
              return UnwrapVpnTrafficFilter(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::Vpn::IVpnProfile^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIVpnProfile(::Windows::Networking::Vpn::IVpnProfile^ wintRtInstance);
      friend ::Windows::Networking::Vpn::IVpnProfile^ UnwrapIVpnProfile(Local<Value> value);
  };

  Persistent<FunctionTemplate> IVpnProfile::s_constructorTemplate;

  v8::Local<v8::Value> WrapIVpnProfile(::Windows::Networking::Vpn::IVpnProfile^ 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>(IVpnProfile::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::IVpnProfile^ UnwrapIVpnProfile(Local<Value> value) {
     return IVpnProfile::Unwrap<IVpnProfile>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIVpnProfile(Local<Object> exports) {
    IVpnProfile::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "append", Append);
            Nan::SetPrototypeMethod(localRef, "addAtBegin", AddAtBegin);
            Nan::SetPrototypeMethod(localRef, "removeAtEnd", RemoveAtEnd);
            Nan::SetPrototypeMethod(localRef, "removeAtBegin", RemoveAtBegin);
            Nan::SetPrototypeMethod(localRef, "clear", Clear);
            Nan::SetPrototypeMethod(localRef, "first", First);
          



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

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



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

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

    private:

      VpnPacketBufferList(::Windows::Networking::Vpn::VpnPacketBufferList^ 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::Networking::Vpn::VpnPacketBufferList^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPacketBufferList^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPacketBuffer^>(info[0]))
      {
        try
        {
          ::Windows::Networking::Vpn::VpnPacketBuffer^ arg0 = UnwrapVpnPacketBuffer(info[0]);
          
          wrapper->_instance->Append(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 AddAtBegin(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPacketBufferList^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPacketBuffer^>(info[0]))
      {
        try
        {
          ::Windows::Networking::Vpn::VpnPacketBuffer^ arg0 = UnwrapVpnPacketBuffer(info[0]);
          
          wrapper->_instance->AddAtBegin(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 RemoveAtEnd(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPacketBufferList^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Networking::Vpn::VpnPacketBuffer^ result;
          result = wrapper->_instance->RemoveAtEnd();
          info.GetReturnValue().Set(WrapVpnPacketBuffer(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 RemoveAtBegin(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPacketBufferList^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Networking::Vpn::VpnPacketBuffer^ result;
          result = wrapper->_instance->RemoveAtBegin();
          info.GetReturnValue().Set(WrapVpnPacketBuffer(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 Clear(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPacketBufferList^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPacketBufferList^>(info.This())) {
        return;
      }

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

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



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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPacketBufferList^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPacketBufferList^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Networking::Vpn::VpnPacketBufferStatus winRtValue = static_cast<::Windows::Networking::Vpn::VpnPacketBufferStatus>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPacketBufferList^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Networking::Vpn::VpnPacketBufferList^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnPacketBufferList(::Windows::Networking::Vpn::VpnPacketBufferList^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnPacketBufferList^ UnwrapVpnPacketBufferList(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnPacketBufferList::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnPacketBufferList(::Windows::Networking::Vpn::VpnPacketBufferList^ 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>(VpnPacketBufferList::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnPacketBufferList^ UnwrapVpnPacketBufferList(Local<Value> value) {
     return VpnPacketBufferList::Unwrap<VpnPacketBufferList>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnPacketBufferList(Local<Object> exports) {
    VpnPacketBufferList::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("noEcho").ToLocalChecked(), NoEchoGetter, NoEchoSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("defaultText").ToLocalChecked(), DefaultTextGetter, DefaultTextSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("text").ToLocalChecked(), TextGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("label").ToLocalChecked(), LabelGetter, LabelSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("compulsory").ToLocalChecked(), CompulsoryGetter, CompulsorySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("bordered").ToLocalChecked(), BorderedGetter, BorderedSetter);

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



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

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

    private:

      VpnCustomEditBox(::Windows::Networking::Vpn::VpnCustomEditBox^ 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::Networking::Vpn::VpnCustomEditBox^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomEditBox^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->NoEcho;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void NoEchoSetter(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::Networking::Vpn::VpnCustomEditBox^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomEditBox^>(info.This())) {
        return;
      }

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

      try  {
        Platform::String^ result = wrapper->_instance->DefaultText;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DefaultTextSetter(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::Networking::Vpn::VpnCustomEditBox^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomEditBox^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomEditBox^>(info.This())) {
        return;
      }

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

      try  {
        Platform::String^ result = wrapper->_instance->Label;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void LabelSetter(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::Networking::Vpn::VpnCustomEditBox^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomEditBox^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->Compulsory;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CompulsorySetter(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::Networking::Vpn::VpnCustomEditBox^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomEditBox^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->Bordered;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BorderedSetter(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::Networking::Vpn::VpnCustomEditBox^>(info.This())) {
        return;
      }

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

      try {

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

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


    private:
      ::Windows::Networking::Vpn::VpnCustomEditBox^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnCustomEditBox(::Windows::Networking::Vpn::VpnCustomEditBox^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnCustomEditBox^ UnwrapVpnCustomEditBox(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnCustomEditBox::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnCustomEditBox(::Windows::Networking::Vpn::VpnCustomEditBox^ 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>(VpnCustomEditBox::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnCustomEditBox^ UnwrapVpnCustomEditBox(Local<Value> value) {
     return VpnCustomEditBox::Unwrap<VpnCustomEditBox>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnCustomEditBox(Local<Object> exports) {
    VpnCustomEditBox::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("emphasized").ToLocalChecked(), EmphasizedGetter, EmphasizedSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("displayName").ToLocalChecked(), DisplayNameGetter, DisplayNameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("compulsory").ToLocalChecked(), CompulsoryGetter, CompulsorySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("placeholderText").ToLocalChecked(), PlaceholderTextGetter, PlaceholderTextSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isTextHidden").ToLocalChecked(), IsTextHiddenGetter, IsTextHiddenSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("text").ToLocalChecked(), TextGetter);

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



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

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

    private:

      VpnCustomPromptTextInput(::Windows::Networking::Vpn::VpnCustomPromptTextInput^ 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::Networking::Vpn::VpnCustomPromptTextInput^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomPromptTextInput^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->Emphasized;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void EmphasizedSetter(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::Networking::Vpn::VpnCustomPromptTextInput^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomPromptTextInput^>(info.This())) {
        return;
      }

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

      try  {
        Platform::String^ result = wrapper->_instance->DisplayName;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DisplayNameSetter(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::Networking::Vpn::VpnCustomPromptTextInput^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomPromptTextInput^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->Compulsory;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CompulsorySetter(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::Networking::Vpn::VpnCustomPromptTextInput^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomPromptTextInput^>(info.This())) {
        return;
      }

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

      try  {
        Platform::String^ result = wrapper->_instance->PlaceholderText;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PlaceholderTextSetter(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::Networking::Vpn::VpnCustomPromptTextInput^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomPromptTextInput^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->IsTextHidden;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsTextHiddenSetter(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::Networking::Vpn::VpnCustomPromptTextInput^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomPromptTextInput^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Networking::Vpn::VpnCustomPromptTextInput^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnCustomPromptTextInput(::Windows::Networking::Vpn::VpnCustomPromptTextInput^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnCustomPromptTextInput^ UnwrapVpnCustomPromptTextInput(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnCustomPromptTextInput::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnCustomPromptTextInput(::Windows::Networking::Vpn::VpnCustomPromptTextInput^ 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>(VpnCustomPromptTextInput::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnCustomPromptTextInput^ UnwrapVpnCustomPromptTextInput(Local<Value> value) {
     return VpnCustomPromptTextInput::Unwrap<VpnCustomPromptTextInput>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnCustomPromptTextInput(Local<Object> exports) {
    VpnCustomPromptTextInput::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("optionsText").ToLocalChecked(), OptionsTextGetter, OptionsTextSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("selected").ToLocalChecked(), SelectedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("label").ToLocalChecked(), LabelGetter, LabelSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("compulsory").ToLocalChecked(), CompulsoryGetter, CompulsorySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("bordered").ToLocalChecked(), BorderedGetter, BorderedSetter);

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



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

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

    private:

      VpnCustomComboBox(::Windows::Networking::Vpn::VpnCustomComboBox^ 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::Networking::Vpn::VpnCustomComboBox^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomComboBox^>(info.This())) {
        return;
      }

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

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

      if (!(NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IVectorView<::Platform::String^>^>(value) || value->IsArray())) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomComboBox^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Foundation::Collections::IVectorView<::Platform::String^>^ winRtValue = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IVectorView<::Platform::String^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVectorView<::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::IVectorView<::Platform::String^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (value);

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomComboBox^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomComboBox^>(info.This())) {
        return;
      }

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

      try  {
        Platform::String^ result = wrapper->_instance->Label;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void LabelSetter(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::Networking::Vpn::VpnCustomComboBox^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomComboBox^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->Compulsory;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CompulsorySetter(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::Networking::Vpn::VpnCustomComboBox^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomComboBox^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->Bordered;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BorderedSetter(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::Networking::Vpn::VpnCustomComboBox^>(info.This())) {
        return;
      }

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

      try {

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

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


    private:
      ::Windows::Networking::Vpn::VpnCustomComboBox^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnCustomComboBox(::Windows::Networking::Vpn::VpnCustomComboBox^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnCustomComboBox^ UnwrapVpnCustomComboBox(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnCustomComboBox::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnCustomComboBox(::Windows::Networking::Vpn::VpnCustomComboBox^ 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>(VpnCustomComboBox::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnCustomComboBox^ UnwrapVpnCustomComboBox(Local<Value> value) {
     return VpnCustomComboBox::Unwrap<VpnCustomComboBox>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnCustomComboBox(Local<Object> exports) {
    VpnCustomComboBox::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("emphasized").ToLocalChecked(), EmphasizedGetter, EmphasizedSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("displayName").ToLocalChecked(), DisplayNameGetter, DisplayNameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("compulsory").ToLocalChecked(), CompulsoryGetter, CompulsorySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("options").ToLocalChecked(), OptionsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("selectedIndex").ToLocalChecked(), SelectedIndexGetter);

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



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

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

    private:

      VpnCustomPromptOptionSelector(::Windows::Networking::Vpn::VpnCustomPromptOptionSelector^ 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::Networking::Vpn::VpnCustomPromptOptionSelector^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomPromptOptionSelector^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->Emphasized;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void EmphasizedSetter(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::Networking::Vpn::VpnCustomPromptOptionSelector^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomPromptOptionSelector^>(info.This())) {
        return;
      }

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

      try  {
        Platform::String^ result = wrapper->_instance->DisplayName;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DisplayNameSetter(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::Networking::Vpn::VpnCustomPromptOptionSelector^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomPromptOptionSelector^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->Compulsory;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CompulsorySetter(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::Networking::Vpn::VpnCustomPromptOptionSelector^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomPromptOptionSelector^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomPromptOptionSelector^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Networking::Vpn::VpnCustomPromptOptionSelector^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnCustomPromptOptionSelector(::Windows::Networking::Vpn::VpnCustomPromptOptionSelector^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnCustomPromptOptionSelector^ UnwrapVpnCustomPromptOptionSelector(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnCustomPromptOptionSelector::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnCustomPromptOptionSelector(::Windows::Networking::Vpn::VpnCustomPromptOptionSelector^ 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>(VpnCustomPromptOptionSelector::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnCustomPromptOptionSelector^ UnwrapVpnCustomPromptOptionSelector(Local<Value> value) {
     return VpnCustomPromptOptionSelector::Unwrap<VpnCustomPromptOptionSelector>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnCustomPromptOptionSelector(Local<Object> exports) {
    VpnCustomPromptOptionSelector::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("label").ToLocalChecked(), LabelGetter, LabelSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("compulsory").ToLocalChecked(), CompulsoryGetter, CompulsorySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("bordered").ToLocalChecked(), BorderedGetter, BorderedSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("displayText").ToLocalChecked(), DisplayTextGetter, DisplayTextSetter);

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



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

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

    private:

      VpnCustomTextBox(::Windows::Networking::Vpn::VpnCustomTextBox^ 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::Networking::Vpn::VpnCustomTextBox^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomTextBox^>(info.This())) {
        return;
      }

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

      try  {
        Platform::String^ result = wrapper->_instance->Label;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void LabelSetter(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::Networking::Vpn::VpnCustomTextBox^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomTextBox^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->Compulsory;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CompulsorySetter(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::Networking::Vpn::VpnCustomTextBox^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomTextBox^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->Bordered;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BorderedSetter(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::Networking::Vpn::VpnCustomTextBox^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomTextBox^>(info.This())) {
        return;
      }

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

      try  {
        Platform::String^ result = wrapper->_instance->DisplayText;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DisplayTextSetter(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::Networking::Vpn::VpnCustomTextBox^>(info.This())) {
        return;
      }

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

      try {

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

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


    private:
      ::Windows::Networking::Vpn::VpnCustomTextBox^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnCustomTextBox(::Windows::Networking::Vpn::VpnCustomTextBox^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnCustomTextBox^ UnwrapVpnCustomTextBox(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnCustomTextBox::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnCustomTextBox(::Windows::Networking::Vpn::VpnCustomTextBox^ 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>(VpnCustomTextBox::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnCustomTextBox^ UnwrapVpnCustomTextBox(Local<Value> value) {
     return VpnCustomTextBox::Unwrap<VpnCustomTextBox>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnCustomTextBox(Local<Object> exports) {
    VpnCustomTextBox::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("emphasized").ToLocalChecked(), EmphasizedGetter, EmphasizedSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("displayName").ToLocalChecked(), DisplayNameGetter, DisplayNameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("compulsory").ToLocalChecked(), CompulsoryGetter, CompulsorySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("text").ToLocalChecked(), TextGetter, TextSetter);

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



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

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

    private:

      VpnCustomPromptText(::Windows::Networking::Vpn::VpnCustomPromptText^ 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::Networking::Vpn::VpnCustomPromptText^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomPromptText^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->Emphasized;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void EmphasizedSetter(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::Networking::Vpn::VpnCustomPromptText^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomPromptText^>(info.This())) {
        return;
      }

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

      try  {
        Platform::String^ result = wrapper->_instance->DisplayName;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DisplayNameSetter(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::Networking::Vpn::VpnCustomPromptText^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomPromptText^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->Compulsory;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CompulsorySetter(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::Networking::Vpn::VpnCustomPromptText^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomPromptText^>(info.This())) {
        return;
      }

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

      try  {
        Platform::String^ result = wrapper->_instance->Text;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TextSetter(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::Networking::Vpn::VpnCustomPromptText^>(info.This())) {
        return;
      }

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

      try {

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

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


    private:
      ::Windows::Networking::Vpn::VpnCustomPromptText^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnCustomPromptText(::Windows::Networking::Vpn::VpnCustomPromptText^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnCustomPromptText^ UnwrapVpnCustomPromptText(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnCustomPromptText::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnCustomPromptText(::Windows::Networking::Vpn::VpnCustomPromptText^ 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>(VpnCustomPromptText::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnCustomPromptText^ UnwrapVpnCustomPromptText(Local<Value> value) {
     return VpnCustomPromptText::Unwrap<VpnCustomPromptText>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnCustomPromptText(Local<Object> exports) {
    VpnCustomPromptText::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("initialCheckState").ToLocalChecked(), InitialCheckStateGetter, InitialCheckStateSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("checked").ToLocalChecked(), CheckedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("label").ToLocalChecked(), LabelGetter, LabelSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("compulsory").ToLocalChecked(), CompulsoryGetter, CompulsorySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("bordered").ToLocalChecked(), BorderedGetter, BorderedSetter);

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



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

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

    private:

      VpnCustomCheckBox(::Windows::Networking::Vpn::VpnCustomCheckBox^ 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::Networking::Vpn::VpnCustomCheckBox^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomCheckBox^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->InitialCheckState;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void InitialCheckStateSetter(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::Networking::Vpn::VpnCustomCheckBox^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomCheckBox^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomCheckBox^>(info.This())) {
        return;
      }

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

      try  {
        Platform::String^ result = wrapper->_instance->Label;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void LabelSetter(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::Networking::Vpn::VpnCustomCheckBox^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomCheckBox^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->Compulsory;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CompulsorySetter(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::Networking::Vpn::VpnCustomCheckBox^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomCheckBox^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->Bordered;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BorderedSetter(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::Networking::Vpn::VpnCustomCheckBox^>(info.This())) {
        return;
      }

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

      try {

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

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


    private:
      ::Windows::Networking::Vpn::VpnCustomCheckBox^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnCustomCheckBox(::Windows::Networking::Vpn::VpnCustomCheckBox^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnCustomCheckBox^ UnwrapVpnCustomCheckBox(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnCustomCheckBox::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnCustomCheckBox(::Windows::Networking::Vpn::VpnCustomCheckBox^ 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>(VpnCustomCheckBox::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnCustomCheckBox^ UnwrapVpnCustomCheckBox(Local<Value> value) {
     return VpnCustomCheckBox::Unwrap<VpnCustomCheckBox>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnCustomCheckBox(Local<Object> exports) {
    VpnCustomCheckBox::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("initialValue").ToLocalChecked(), InitialValueGetter, InitialValueSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("value").ToLocalChecked(), ValueGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("emphasized").ToLocalChecked(), EmphasizedGetter, EmphasizedSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("displayName").ToLocalChecked(), DisplayNameGetter, DisplayNameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("compulsory").ToLocalChecked(), CompulsoryGetter, CompulsorySetter);

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



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

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

    private:

      VpnCustomPromptBooleanInput(::Windows::Networking::Vpn::VpnCustomPromptBooleanInput^ 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::Networking::Vpn::VpnCustomPromptBooleanInput^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomPromptBooleanInput^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->InitialValue;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void InitialValueSetter(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::Networking::Vpn::VpnCustomPromptBooleanInput^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomPromptBooleanInput^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomPromptBooleanInput^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->Emphasized;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void EmphasizedSetter(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::Networking::Vpn::VpnCustomPromptBooleanInput^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomPromptBooleanInput^>(info.This())) {
        return;
      }

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

      try  {
        Platform::String^ result = wrapper->_instance->DisplayName;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DisplayNameSetter(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::Networking::Vpn::VpnCustomPromptBooleanInput^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomPromptBooleanInput^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->Compulsory;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CompulsorySetter(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::Networking::Vpn::VpnCustomPromptBooleanInput^>(info.This())) {
        return;
      }

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

      try {

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

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


    private:
      ::Windows::Networking::Vpn::VpnCustomPromptBooleanInput^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnCustomPromptBooleanInput(::Windows::Networking::Vpn::VpnCustomPromptBooleanInput^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnCustomPromptBooleanInput^ UnwrapVpnCustomPromptBooleanInput(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnCustomPromptBooleanInput::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnCustomPromptBooleanInput(::Windows::Networking::Vpn::VpnCustomPromptBooleanInput^ 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>(VpnCustomPromptBooleanInput::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnCustomPromptBooleanInput^ UnwrapVpnCustomPromptBooleanInput(Local<Value> value) {
     return VpnCustomPromptBooleanInput::Unwrap<VpnCustomPromptBooleanInput>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnCustomPromptBooleanInput(Local<Object> exports) {
    VpnCustomPromptBooleanInput::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("label").ToLocalChecked(), LabelGetter, LabelSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("compulsory").ToLocalChecked(), CompulsoryGetter, CompulsorySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("bordered").ToLocalChecked(), BorderedGetter, BorderedSetter);

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



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

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

    private:

      VpnCustomErrorBox(::Windows::Networking::Vpn::VpnCustomErrorBox^ 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::Networking::Vpn::VpnCustomErrorBox^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomErrorBox^>(info.This())) {
        return;
      }

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

      try  {
        Platform::String^ result = wrapper->_instance->Label;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void LabelSetter(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::Networking::Vpn::VpnCustomErrorBox^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomErrorBox^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->Compulsory;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CompulsorySetter(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::Networking::Vpn::VpnCustomErrorBox^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnCustomErrorBox^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->Bordered;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BorderedSetter(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::Networking::Vpn::VpnCustomErrorBox^>(info.This())) {
        return;
      }

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

      try {

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

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


    private:
      ::Windows::Networking::Vpn::VpnCustomErrorBox^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnCustomErrorBox(::Windows::Networking::Vpn::VpnCustomErrorBox^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnCustomErrorBox^ UnwrapVpnCustomErrorBox(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnCustomErrorBox::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnCustomErrorBox(::Windows::Networking::Vpn::VpnCustomErrorBox^ 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>(VpnCustomErrorBox::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnCustomErrorBox^ UnwrapVpnCustomErrorBox(Local<Value> value) {
     return VpnCustomErrorBox::Unwrap<VpnCustomErrorBox>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnCustomErrorBox(Local<Object> exports) {
    VpnCustomErrorBox::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("vpnPluginPackageFamilyName").ToLocalChecked(), VpnPluginPackageFamilyNameGetter, VpnPluginPackageFamilyNameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("customConfiguration").ToLocalChecked(), CustomConfigurationGetter, CustomConfigurationSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("serverUris").ToLocalChecked(), ServerUrisGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("requireVpnClientAppUI").ToLocalChecked(), RequireVpnClientAppUIGetter, RequireVpnClientAppUISetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("connectionStatus").ToLocalChecked(), ConnectionStatusGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("profileName").ToLocalChecked(), ProfileNameGetter, ProfileNameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("rememberCredentials").ToLocalChecked(), RememberCredentialsGetter, RememberCredentialsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("alwaysOn").ToLocalChecked(), AlwaysOnGetter, AlwaysOnSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("appTriggers").ToLocalChecked(), AppTriggersGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("domainNameInfoList").ToLocalChecked(), DomainNameInfoListGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("routes").ToLocalChecked(), RoutesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("trafficFilters").ToLocalChecked(), TrafficFiltersGetter);

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



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

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

    private:

      VpnPlugInProfile(::Windows::Networking::Vpn::VpnPlugInProfile^ 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::Networking::Vpn::VpnPlugInProfile^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPlugInProfile^>(info.This())) {
        return;
      }

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

      try  {
        Platform::String^ result = wrapper->_instance->VpnPluginPackageFamilyName;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VpnPluginPackageFamilyNameSetter(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::Networking::Vpn::VpnPlugInProfile^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPlugInProfile^>(info.This())) {
        return;
      }

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

      try  {
        Platform::String^ result = wrapper->_instance->CustomConfiguration;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CustomConfigurationSetter(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::Networking::Vpn::VpnPlugInProfile^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPlugInProfile^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::Foundation::Uri^>^ result = wrapper->_instance->ServerUris;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Foundation::Uri^>::CreateVectorWrapper(result, 
            [](::Windows::Foundation::Uri^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "Uri", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(value);
            },
            [](Local<Value> value) -> ::Windows::Foundation::Uri^ {
              return dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RequireVpnClientAppUIGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPlugInProfile^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->RequireVpnClientAppUI;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RequireVpnClientAppUISetter(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::Networking::Vpn::VpnPlugInProfile^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPlugInProfile^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPlugInProfile^>(info.This())) {
        return;
      }

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

      try  {
        Platform::String^ result = wrapper->_instance->ProfileName;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ProfileNameSetter(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::Networking::Vpn::VpnPlugInProfile^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPlugInProfile^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->RememberCredentials;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RememberCredentialsSetter(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::Networking::Vpn::VpnPlugInProfile^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPlugInProfile^>(info.This())) {
        return;
      }

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

      try  {
        bool result = wrapper->_instance->AlwaysOn;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AlwaysOnSetter(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::Networking::Vpn::VpnPlugInProfile^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPlugInProfile^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnAppId^>^ result = wrapper->_instance->AppTriggers;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Networking::Vpn::VpnAppId^>::CreateVectorWrapper(result, 
            [](::Windows::Networking::Vpn::VpnAppId^ val) -> Local<Value> {
              return WrapVpnAppId(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnAppId^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::Vpn::VpnAppId^ {
              return UnwrapVpnAppId(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DomainNameInfoListGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPlugInProfile^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnDomainNameInfo^>^ result = wrapper->_instance->DomainNameInfoList;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Networking::Vpn::VpnDomainNameInfo^>::CreateVectorWrapper(result, 
            [](::Windows::Networking::Vpn::VpnDomainNameInfo^ val) -> Local<Value> {
              return WrapVpnDomainNameInfo(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnDomainNameInfo^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::Vpn::VpnDomainNameInfo^ {
              return UnwrapVpnDomainNameInfo(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RoutesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPlugInProfile^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnRoute^>^ result = wrapper->_instance->Routes;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Networking::Vpn::VpnRoute^>::CreateVectorWrapper(result, 
            [](::Windows::Networking::Vpn::VpnRoute^ val) -> Local<Value> {
              return WrapVpnRoute(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnRoute^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::Vpn::VpnRoute^ {
              return UnwrapVpnRoute(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TrafficFiltersGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnPlugInProfile^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnTrafficFilter^>^ result = wrapper->_instance->TrafficFilters;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Networking::Vpn::VpnTrafficFilter^>::CreateVectorWrapper(result, 
            [](::Windows::Networking::Vpn::VpnTrafficFilter^ val) -> Local<Value> {
              return WrapVpnTrafficFilter(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnTrafficFilter^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::Vpn::VpnTrafficFilter^ {
              return UnwrapVpnTrafficFilter(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::Vpn::VpnPlugInProfile^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnPlugInProfile(::Windows::Networking::Vpn::VpnPlugInProfile^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnPlugInProfile^ UnwrapVpnPlugInProfile(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnPlugInProfile::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnPlugInProfile(::Windows::Networking::Vpn::VpnPlugInProfile^ 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>(VpnPlugInProfile::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnPlugInProfile^ UnwrapVpnPlugInProfile(Local<Value> value) {
     return VpnPlugInProfile::Unwrap<VpnPlugInProfile>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnPlugInProfile(Local<Object> exports) {
    VpnPlugInProfile::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("userAuthenticationMethod").ToLocalChecked(), UserAuthenticationMethodGetter, UserAuthenticationMethodSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("tunnelAuthenticationMethod").ToLocalChecked(), TunnelAuthenticationMethodGetter, TunnelAuthenticationMethodSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("routingPolicyType").ToLocalChecked(), RoutingPolicyTypeGetter, RoutingPolicyTypeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("eapConfiguration").ToLocalChecked(), EapConfigurationGetter, EapConfigurationSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("nativeProtocolType").ToLocalChecked(), NativeProtocolTypeGetter, NativeProtocolTypeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("servers").ToLocalChecked(), ServersGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("requireVpnClientAppUI").ToLocalChecked(), RequireVpnClientAppUIGetter, RequireVpnClientAppUISetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("connectionStatus").ToLocalChecked(), ConnectionStatusGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("profileName").ToLocalChecked(), ProfileNameGetter, ProfileNameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("rememberCredentials").ToLocalChecked(), RememberCredentialsGetter, RememberCredentialsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("alwaysOn").ToLocalChecked(), AlwaysOnGetter, AlwaysOnSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("routes").ToLocalChecked(), RoutesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("appTriggers").ToLocalChecked(), AppTriggersGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("trafficFilters").ToLocalChecked(), TrafficFiltersGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("domainNameInfoList").ToLocalChecked(), DomainNameInfoListGetter);

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



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

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

    private:

      VpnNativeProfile(::Windows::Networking::Vpn::VpnNativeProfile^ 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::Networking::Vpn::VpnNativeProfile^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNativeProfile^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::Vpn::VpnNativeProfile^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::Networking::Vpn::VpnNativeProfile();
        } 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());

      VpnNativeProfile *wrapperInstance = new VpnNativeProfile(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::Networking::Vpn::VpnNativeProfile^>(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::Networking::Vpn::VpnNativeProfile^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::Vpn::VpnNativeProfile^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapVpnNativeProfile(winRtInstance));
    }





    static void UserAuthenticationMethodGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNativeProfile^>(info.This())) {
        return;
      }

      VpnNativeProfile *wrapper = VpnNativeProfile::Unwrap<VpnNativeProfile>(info.This());

      try  {
        ::Windows::Networking::Vpn::VpnAuthenticationMethod result = wrapper->_instance->UserAuthenticationMethod;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void UserAuthenticationMethodSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNativeProfile^>(info.This())) {
        return;
      }

      VpnNativeProfile *wrapper = VpnNativeProfile::Unwrap<VpnNativeProfile>(info.This());

      try {

        ::Windows::Networking::Vpn::VpnAuthenticationMethod winRtValue = static_cast<::Windows::Networking::Vpn::VpnAuthenticationMethod>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->UserAuthenticationMethod = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void TunnelAuthenticationMethodGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNativeProfile^>(info.This())) {
        return;
      }

      VpnNativeProfile *wrapper = VpnNativeProfile::Unwrap<VpnNativeProfile>(info.This());

      try  {
        ::Windows::Networking::Vpn::VpnAuthenticationMethod result = wrapper->_instance->TunnelAuthenticationMethod;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TunnelAuthenticationMethodSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNativeProfile^>(info.This())) {
        return;
      }

      VpnNativeProfile *wrapper = VpnNativeProfile::Unwrap<VpnNativeProfile>(info.This());

      try {

        ::Windows::Networking::Vpn::VpnAuthenticationMethod winRtValue = static_cast<::Windows::Networking::Vpn::VpnAuthenticationMethod>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->TunnelAuthenticationMethod = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void RoutingPolicyTypeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNativeProfile^>(info.This())) {
        return;
      }

      VpnNativeProfile *wrapper = VpnNativeProfile::Unwrap<VpnNativeProfile>(info.This());

      try  {
        ::Windows::Networking::Vpn::VpnRoutingPolicyType result = wrapper->_instance->RoutingPolicyType;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RoutingPolicyTypeSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNativeProfile^>(info.This())) {
        return;
      }

      VpnNativeProfile *wrapper = VpnNativeProfile::Unwrap<VpnNativeProfile>(info.This());

      try {

        ::Windows::Networking::Vpn::VpnRoutingPolicyType winRtValue = static_cast<::Windows::Networking::Vpn::VpnRoutingPolicyType>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->RoutingPolicyType = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void EapConfigurationGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNativeProfile^>(info.This())) {
        return;
      }

      VpnNativeProfile *wrapper = VpnNativeProfile::Unwrap<VpnNativeProfile>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->EapConfiguration;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void EapConfigurationSetter(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::Networking::Vpn::VpnNativeProfile^>(info.This())) {
        return;
      }

      VpnNativeProfile *wrapper = VpnNativeProfile::Unwrap<VpnNativeProfile>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->EapConfiguration = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void NativeProtocolTypeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNativeProfile^>(info.This())) {
        return;
      }

      VpnNativeProfile *wrapper = VpnNativeProfile::Unwrap<VpnNativeProfile>(info.This());

      try  {
        ::Windows::Networking::Vpn::VpnNativeProtocolType result = wrapper->_instance->NativeProtocolType;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void NativeProtocolTypeSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsInt32()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNativeProfile^>(info.This())) {
        return;
      }

      VpnNativeProfile *wrapper = VpnNativeProfile::Unwrap<VpnNativeProfile>(info.This());

      try {

        ::Windows::Networking::Vpn::VpnNativeProtocolType winRtValue = static_cast<::Windows::Networking::Vpn::VpnNativeProtocolType>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->NativeProtocolType = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ServersGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNativeProfile^>(info.This())) {
        return;
      }

      VpnNativeProfile *wrapper = VpnNativeProfile::Unwrap<VpnNativeProfile>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVector<::Platform::String^>^ result = wrapper->_instance->Servers;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Platform::String^>::CreateVectorWrapper(result, 
            [](::Platform::String^ val) -> Local<Value> {
              return NodeRT::Utils::NewString(val->Data());
            },
            [](Local<Value> value) -> bool {
              return value->IsString();
            },
            [](Local<Value> value) -> ::Platform::String^ {
              return ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RequireVpnClientAppUIGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNativeProfile^>(info.This())) {
        return;
      }

      VpnNativeProfile *wrapper = VpnNativeProfile::Unwrap<VpnNativeProfile>(info.This());

      try  {
        bool result = wrapper->_instance->RequireVpnClientAppUI;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RequireVpnClientAppUISetter(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::Networking::Vpn::VpnNativeProfile^>(info.This())) {
        return;
      }

      VpnNativeProfile *wrapper = VpnNativeProfile::Unwrap<VpnNativeProfile>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->RequireVpnClientAppUI = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ConnectionStatusGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNativeProfile^>(info.This())) {
        return;
      }

      VpnNativeProfile *wrapper = VpnNativeProfile::Unwrap<VpnNativeProfile>(info.This());

      try  {
        ::Windows::Networking::Vpn::VpnManagementConnectionStatus result = wrapper->_instance->ConnectionStatus;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ProfileNameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNativeProfile^>(info.This())) {
        return;
      }

      VpnNativeProfile *wrapper = VpnNativeProfile::Unwrap<VpnNativeProfile>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->ProfileName;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ProfileNameSetter(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::Networking::Vpn::VpnNativeProfile^>(info.This())) {
        return;
      }

      VpnNativeProfile *wrapper = VpnNativeProfile::Unwrap<VpnNativeProfile>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->ProfileName = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void RememberCredentialsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNativeProfile^>(info.This())) {
        return;
      }

      VpnNativeProfile *wrapper = VpnNativeProfile::Unwrap<VpnNativeProfile>(info.This());

      try  {
        bool result = wrapper->_instance->RememberCredentials;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RememberCredentialsSetter(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::Networking::Vpn::VpnNativeProfile^>(info.This())) {
        return;
      }

      VpnNativeProfile *wrapper = VpnNativeProfile::Unwrap<VpnNativeProfile>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->RememberCredentials = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void AlwaysOnGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNativeProfile^>(info.This())) {
        return;
      }

      VpnNativeProfile *wrapper = VpnNativeProfile::Unwrap<VpnNativeProfile>(info.This());

      try  {
        bool result = wrapper->_instance->AlwaysOn;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AlwaysOnSetter(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::Networking::Vpn::VpnNativeProfile^>(info.This())) {
        return;
      }

      VpnNativeProfile *wrapper = VpnNativeProfile::Unwrap<VpnNativeProfile>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->AlwaysOn = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void RoutesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNativeProfile^>(info.This())) {
        return;
      }

      VpnNativeProfile *wrapper = VpnNativeProfile::Unwrap<VpnNativeProfile>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnRoute^>^ result = wrapper->_instance->Routes;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Networking::Vpn::VpnRoute^>::CreateVectorWrapper(result, 
            [](::Windows::Networking::Vpn::VpnRoute^ val) -> Local<Value> {
              return WrapVpnRoute(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnRoute^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::Vpn::VpnRoute^ {
              return UnwrapVpnRoute(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AppTriggersGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNativeProfile^>(info.This())) {
        return;
      }

      VpnNativeProfile *wrapper = VpnNativeProfile::Unwrap<VpnNativeProfile>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnAppId^>^ result = wrapper->_instance->AppTriggers;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Networking::Vpn::VpnAppId^>::CreateVectorWrapper(result, 
            [](::Windows::Networking::Vpn::VpnAppId^ val) -> Local<Value> {
              return WrapVpnAppId(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnAppId^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::Vpn::VpnAppId^ {
              return UnwrapVpnAppId(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TrafficFiltersGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNativeProfile^>(info.This())) {
        return;
      }

      VpnNativeProfile *wrapper = VpnNativeProfile::Unwrap<VpnNativeProfile>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnTrafficFilter^>^ result = wrapper->_instance->TrafficFilters;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Networking::Vpn::VpnTrafficFilter^>::CreateVectorWrapper(result, 
            [](::Windows::Networking::Vpn::VpnTrafficFilter^ val) -> Local<Value> {
              return WrapVpnTrafficFilter(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnTrafficFilter^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::Vpn::VpnTrafficFilter^ {
              return UnwrapVpnTrafficFilter(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DomainNameInfoListGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnNativeProfile^>(info.This())) {
        return;
      }

      VpnNativeProfile *wrapper = VpnNativeProfile::Unwrap<VpnNativeProfile>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::Networking::Vpn::VpnDomainNameInfo^>^ result = wrapper->_instance->DomainNameInfoList;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Networking::Vpn::VpnDomainNameInfo^>::CreateVectorWrapper(result, 
            [](::Windows::Networking::Vpn::VpnDomainNameInfo^ val) -> Local<Value> {
              return WrapVpnDomainNameInfo(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnDomainNameInfo^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::Vpn::VpnDomainNameInfo^ {
              return UnwrapVpnDomainNameInfo(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::Vpn::VpnNativeProfile^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnNativeProfile(::Windows::Networking::Vpn::VpnNativeProfile^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnNativeProfile^ UnwrapVpnNativeProfile(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnNativeProfile::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnNativeProfile(::Windows::Networking::Vpn::VpnNativeProfile^ 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>(VpnNativeProfile::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnNativeProfile^ UnwrapVpnNativeProfile(Local<Value> value) {
     return VpnNativeProfile::Unwrap<VpnNativeProfile>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnNativeProfile(Local<Object> exports) {
    VpnNativeProfile::Init(exports);
  }

  class VpnManagementAgent : 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>("VpnManagementAgent").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);

        Local<Function> func;
        Local<FunctionTemplate> funcTemplate;


          
            Nan::SetPrototypeMethod(localRef, "addProfileFromXmlAsync", AddProfileFromXmlAsync);
            Nan::SetPrototypeMethod(localRef, "addProfileFromObjectAsync", AddProfileFromObjectAsync);
            Nan::SetPrototypeMethod(localRef, "updateProfileFromXmlAsync", UpdateProfileFromXmlAsync);
            Nan::SetPrototypeMethod(localRef, "updateProfileFromObjectAsync", UpdateProfileFromObjectAsync);
            Nan::SetPrototypeMethod(localRef, "getProfilesAsync", GetProfilesAsync);
            Nan::SetPrototypeMethod(localRef, "deleteProfileAsync", DeleteProfileAsync);
            Nan::SetPrototypeMethod(localRef, "connectProfileAsync", ConnectProfileAsync);
            Nan::SetPrototypeMethod(localRef, "connectProfileWithPasswordCredentialAsync", ConnectProfileWithPasswordCredentialAsync);
            Nan::SetPrototypeMethod(localRef, "disconnectProfileAsync", DisconnectProfileAsync);
          



        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("VpnManagementAgent").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      VpnManagementAgent(::Windows::Networking::Vpn::VpnManagementAgent^ 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::Networking::Vpn::VpnManagementAgent^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnManagementAgent^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::Vpn::VpnManagementAgent^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::Networking::Vpn::VpnManagementAgent();
        } 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());

      VpnManagementAgent *wrapperInstance = new VpnManagementAgent(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::Networking::Vpn::VpnManagementAgent^>(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::Networking::Vpn::VpnManagementAgent^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::Vpn::VpnManagementAgent^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapVpnManagementAgent(winRtInstance));
    }

    static void AddProfileFromXmlAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnManagementAgent^>(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;
      }

      VpnManagementAgent *wrapper = VpnManagementAgent::Unwrap<VpnManagementAgent>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::Vpn::VpnManagementErrorStatus>^ 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->AddProfileFromXmlAsync(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::Networking::Vpn::VpnManagementErrorStatus> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = Nan::New<Integer>(static_cast<int>(result));
              if (tryCatch.HasCaught())
              {
                error = Nan::To<Object>(tryCatch.Exception()).ToLocalChecked();
              }
              else
              {
                error = Undefined();
              }
              if (arg1.IsEmpty()) arg1 = Undefined();
            }
            Local<Value> args[] = {error, arg1};


            invokeCallback(_countof(args), args);
          });
        } catch (Platform::Exception^ exception) {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {
            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

            Local<Value> args[] = {error};
            invokeCallback(_countof(args), args);
          });
        }
      });
    }
    static void AddProfileFromObjectAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnManagementAgent^>(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;
      }

      VpnManagementAgent *wrapper = VpnManagementAgent::Unwrap<VpnManagementAgent>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::Vpn::VpnManagementErrorStatus>^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnProfile^>(info[0]))
      {
        try
        {
          ::Windows::Networking::Vpn::IVpnProfile^ arg0 = UnwrapIVpnProfile(info[0]);
          
          op = wrapper->_instance->AddProfileFromObjectAsync(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::Networking::Vpn::VpnManagementErrorStatus> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = Nan::New<Integer>(static_cast<int>(result));
              if (tryCatch.HasCaught())
              {
                error = Nan::To<Object>(tryCatch.Exception()).ToLocalChecked();
              }
              else
              {
                error = Undefined();
              }
              if (arg1.IsEmpty()) arg1 = Undefined();
            }
            Local<Value> args[] = {error, arg1};


            invokeCallback(_countof(args), args);
          });
        } catch (Platform::Exception^ exception) {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {
            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

            Local<Value> args[] = {error};
            invokeCallback(_countof(args), args);
          });
        }
      });
    }
    static void UpdateProfileFromXmlAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnManagementAgent^>(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;
      }

      VpnManagementAgent *wrapper = VpnManagementAgent::Unwrap<VpnManagementAgent>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::Vpn::VpnManagementErrorStatus>^ 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->UpdateProfileFromXmlAsync(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::Networking::Vpn::VpnManagementErrorStatus> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = Nan::New<Integer>(static_cast<int>(result));
              if (tryCatch.HasCaught())
              {
                error = Nan::To<Object>(tryCatch.Exception()).ToLocalChecked();
              }
              else
              {
                error = Undefined();
              }
              if (arg1.IsEmpty()) arg1 = Undefined();
            }
            Local<Value> args[] = {error, arg1};


            invokeCallback(_countof(args), args);
          });
        } catch (Platform::Exception^ exception) {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {
            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

            Local<Value> args[] = {error};
            invokeCallback(_countof(args), args);
          });
        }
      });
    }
    static void UpdateProfileFromObjectAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnManagementAgent^>(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;
      }

      VpnManagementAgent *wrapper = VpnManagementAgent::Unwrap<VpnManagementAgent>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::Vpn::VpnManagementErrorStatus>^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnProfile^>(info[0]))
      {
        try
        {
          ::Windows::Networking::Vpn::IVpnProfile^ arg0 = UnwrapIVpnProfile(info[0]);
          
          op = wrapper->_instance->UpdateProfileFromObjectAsync(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::Networking::Vpn::VpnManagementErrorStatus> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = Nan::New<Integer>(static_cast<int>(result));
              if (tryCatch.HasCaught())
              {
                error = Nan::To<Object>(tryCatch.Exception()).ToLocalChecked();
              }
              else
              {
                error = Undefined();
              }
              if (arg1.IsEmpty()) arg1 = Undefined();
            }
            Local<Value> args[] = {error, arg1};


            invokeCallback(_countof(args), args);
          });
        } catch (Platform::Exception^ exception) {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {
            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

            Local<Value> args[] = {error};
            invokeCallback(_countof(args), args);
          });
        }
      });
    }
    static void GetProfilesAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnManagementAgent^>(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;
      }

      VpnManagementAgent *wrapper = VpnManagementAgent::Unwrap<VpnManagementAgent>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::Foundation::Collections::IVectorView<::Windows::Networking::Vpn::IVpnProfile^>^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->GetProfilesAsync();
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

      auto opTask = create_task(op);
      uv_async_t* asyncToken = NodeUtils::Async::GetAsyncToken(info[info.Length() -1].As<Function>());

      opTask.then( [asyncToken] (task<::Windows::Foundation::Collections::IVectorView<::Windows::Networking::Vpn::IVpnProfile^>^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = NodeRT::Collections::VectorViewWrapper<::Windows::Networking::Vpn::IVpnProfile^>::CreateVectorViewWrapper(result, 
            [](::Windows::Networking::Vpn::IVpnProfile^ val) -> Local<Value> {
              return WrapIVpnProfile(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnProfile^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::Vpn::IVpnProfile^ {
              return UnwrapIVpnProfile(value);
            }
          );
              if (tryCatch.HasCaught())
              {
                error = Nan::To<Object>(tryCatch.Exception()).ToLocalChecked();
              }
              else
              {
                error = Undefined();
              }
              if (arg1.IsEmpty()) arg1 = Undefined();
            }
            Local<Value> args[] = {error, arg1};


            invokeCallback(_countof(args), args);
          });
        } catch (Platform::Exception^ exception) {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {
            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

            Local<Value> args[] = {error};
            invokeCallback(_countof(args), args);
          });
        }
      });
    }
    static void DeleteProfileAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnManagementAgent^>(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;
      }

      VpnManagementAgent *wrapper = VpnManagementAgent::Unwrap<VpnManagementAgent>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::Vpn::VpnManagementErrorStatus>^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnProfile^>(info[0]))
      {
        try
        {
          ::Windows::Networking::Vpn::IVpnProfile^ arg0 = UnwrapIVpnProfile(info[0]);
          
          op = wrapper->_instance->DeleteProfileAsync(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::Networking::Vpn::VpnManagementErrorStatus> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = Nan::New<Integer>(static_cast<int>(result));
              if (tryCatch.HasCaught())
              {
                error = Nan::To<Object>(tryCatch.Exception()).ToLocalChecked();
              }
              else
              {
                error = Undefined();
              }
              if (arg1.IsEmpty()) arg1 = Undefined();
            }
            Local<Value> args[] = {error, arg1};


            invokeCallback(_countof(args), args);
          });
        } catch (Platform::Exception^ exception) {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {
            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

            Local<Value> args[] = {error};
            invokeCallback(_countof(args), args);
          });
        }
      });
    }
    static void ConnectProfileAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnManagementAgent^>(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;
      }

      VpnManagementAgent *wrapper = VpnManagementAgent::Unwrap<VpnManagementAgent>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::Vpn::VpnManagementErrorStatus>^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnProfile^>(info[0]))
      {
        try
        {
          ::Windows::Networking::Vpn::IVpnProfile^ arg0 = UnwrapIVpnProfile(info[0]);
          
          op = wrapper->_instance->ConnectProfileAsync(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::Networking::Vpn::VpnManagementErrorStatus> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = Nan::New<Integer>(static_cast<int>(result));
              if (tryCatch.HasCaught())
              {
                error = Nan::To<Object>(tryCatch.Exception()).ToLocalChecked();
              }
              else
              {
                error = Undefined();
              }
              if (arg1.IsEmpty()) arg1 = Undefined();
            }
            Local<Value> args[] = {error, arg1};


            invokeCallback(_countof(args), args);
          });
        } catch (Platform::Exception^ exception) {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {
            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

            Local<Value> args[] = {error};
            invokeCallback(_countof(args), args);
          });
        }
      });
    }
    static void ConnectProfileWithPasswordCredentialAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnManagementAgent^>(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;
      }

      VpnManagementAgent *wrapper = VpnManagementAgent::Unwrap<VpnManagementAgent>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::Vpn::VpnManagementErrorStatus>^ op;


      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnProfile^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Security::Credentials::PasswordCredential^>(info[1]))
      {
        try
        {
          ::Windows::Networking::Vpn::IVpnProfile^ arg0 = UnwrapIVpnProfile(info[0]);
          ::Windows::Security::Credentials::PasswordCredential^ arg1 = dynamic_cast<::Windows::Security::Credentials::PasswordCredential^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          op = wrapper->_instance->ConnectProfileWithPasswordCredentialAsync(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::Networking::Vpn::VpnManagementErrorStatus> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = Nan::New<Integer>(static_cast<int>(result));
              if (tryCatch.HasCaught())
              {
                error = Nan::To<Object>(tryCatch.Exception()).ToLocalChecked();
              }
              else
              {
                error = Undefined();
              }
              if (arg1.IsEmpty()) arg1 = Undefined();
            }
            Local<Value> args[] = {error, arg1};


            invokeCallback(_countof(args), args);
          });
        } catch (Platform::Exception^ exception) {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {
            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

            Local<Value> args[] = {error};
            invokeCallback(_countof(args), args);
          });
        }
      });
    }
    static void DisconnectProfileAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::VpnManagementAgent^>(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;
      }

      VpnManagementAgent *wrapper = VpnManagementAgent::Unwrap<VpnManagementAgent>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::Vpn::VpnManagementErrorStatus>^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Vpn::IVpnProfile^>(info[0]))
      {
        try
        {
          ::Windows::Networking::Vpn::IVpnProfile^ arg0 = UnwrapIVpnProfile(info[0]);
          
          op = wrapper->_instance->DisconnectProfileAsync(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::Networking::Vpn::VpnManagementErrorStatus> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = Nan::New<Integer>(static_cast<int>(result));
              if (tryCatch.HasCaught())
              {
                error = Nan::To<Object>(tryCatch.Exception()).ToLocalChecked();
              }
              else
              {
                error = Undefined();
              }
              if (arg1.IsEmpty()) arg1 = Undefined();
            }
            Local<Value> args[] = {error, arg1};


            invokeCallback(_countof(args), args);
          });
        } catch (Platform::Exception^ exception) {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {
            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

            Local<Value> args[] = {error};
            invokeCallback(_countof(args), args);
          });
        }
      });
    }






    private:
      ::Windows::Networking::Vpn::VpnManagementAgent^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVpnManagementAgent(::Windows::Networking::Vpn::VpnManagementAgent^ wintRtInstance);
      friend ::Windows::Networking::Vpn::VpnManagementAgent^ UnwrapVpnManagementAgent(Local<Value> value);
  };

  Persistent<FunctionTemplate> VpnManagementAgent::s_constructorTemplate;

  v8::Local<v8::Value> WrapVpnManagementAgent(::Windows::Networking::Vpn::VpnManagementAgent^ 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>(VpnManagementAgent::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::Vpn::VpnManagementAgent^ UnwrapVpnManagementAgent(Local<Value> value) {
     return VpnManagementAgent::Unwrap<VpnManagementAgent>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVpnManagementAgent(Local<Object> exports) {
    VpnManagementAgent::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::Networking::Vpn::InitVpnDataPathTypeEnum(target);
      NodeRT::Windows::Networking::Vpn::InitVpnChannelActivityEventTypeEnum(target);
      NodeRT::Windows::Networking::Vpn::InitVpnCredentialTypeEnum(target);
      NodeRT::Windows::Networking::Vpn::InitVpnPacketBufferStatusEnum(target);
      NodeRT::Windows::Networking::Vpn::InitVpnChannelRequestCredentialsOptionsEnum(target);
      NodeRT::Windows::Networking::Vpn::InitVpnDomainNameTypeEnum(target);
      NodeRT::Windows::Networking::Vpn::InitVpnAppIdTypeEnum(target);
      NodeRT::Windows::Networking::Vpn::InitVpnIPProtocolEnum(target);
      NodeRT::Windows::Networking::Vpn::InitVpnRoutingPolicyTypeEnum(target);
      NodeRT::Windows::Networking::Vpn::InitVpnManagementConnectionStatusEnum(target);
      NodeRT::Windows::Networking::Vpn::InitVpnNativeProtocolTypeEnum(target);
      NodeRT::Windows::Networking::Vpn::InitVpnAuthenticationMethodEnum(target);
      NodeRT::Windows::Networking::Vpn::InitVpnManagementErrorStatusEnum(target);
      NodeRT::Windows::Networking::Vpn::InitIVpnPlugIn(target);
      NodeRT::Windows::Networking::Vpn::InitIVpnCustomPrompt(target);
      NodeRT::Windows::Networking::Vpn::InitIVpnRouteFactory(target);
      NodeRT::Windows::Networking::Vpn::InitVpnRoute(target);
      NodeRT::Windows::Networking::Vpn::InitIVpnNamespaceInfoFactory(target);
      NodeRT::Windows::Networking::Vpn::InitVpnNamespaceInfo(target);
      NodeRT::Windows::Networking::Vpn::InitIVpnInterfaceIdFactory(target);
      NodeRT::Windows::Networking::Vpn::InitVpnInterfaceId(target);
      NodeRT::Windows::Networking::Vpn::InitIVpnCredential(target);
      NodeRT::Windows::Networking::Vpn::InitVpnRouteAssignment(target);
      NodeRT::Windows::Networking::Vpn::InitVpnNamespaceAssignment(target);
      NodeRT::Windows::Networking::Vpn::InitVpnPickedCredential(target);
      NodeRT::Windows::Networking::Vpn::InitVpnPacketBuffer(target);
      NodeRT::Windows::Networking::Vpn::InitVpnChannelConfiguration(target);
      NodeRT::Windows::Networking::Vpn::InitVpnChannel(target);
      NodeRT::Windows::Networking::Vpn::InitVpnChannelActivityEventArgs(target);
      NodeRT::Windows::Networking::Vpn::InitVpnSystemHealth(target);
      NodeRT::Windows::Networking::Vpn::InitVpnDomainNameAssignment(target);
      NodeRT::Windows::Networking::Vpn::InitVpnChannelActivityStateChangedArgs(target);
      NodeRT::Windows::Networking::Vpn::InitIVpnCustomPromptElement(target);
      NodeRT::Windows::Networking::Vpn::InitVpnCredential(target);
      NodeRT::Windows::Networking::Vpn::InitVpnTrafficFilterAssignment(target);
      NodeRT::Windows::Networking::Vpn::InitIVpnChannelStatics(target);
      NodeRT::Windows::Networking::Vpn::InitIVpnPacketBufferFactory(target);
      NodeRT::Windows::Networking::Vpn::InitVpnAppId(target);
      NodeRT::Windows::Networking::Vpn::InitIVpnDomainNameInfoFactory(target);
      NodeRT::Windows::Networking::Vpn::InitVpnDomainNameInfo(target);
      NodeRT::Windows::Networking::Vpn::InitVpnTrafficFilter(target);
      NodeRT::Windows::Networking::Vpn::InitIVpnProfile(target);
      NodeRT::Windows::Networking::Vpn::InitVpnPacketBufferList(target);
      NodeRT::Windows::Networking::Vpn::InitVpnCustomEditBox(target);
      NodeRT::Windows::Networking::Vpn::InitVpnCustomPromptTextInput(target);
      NodeRT::Windows::Networking::Vpn::InitVpnCustomComboBox(target);
      NodeRT::Windows::Networking::Vpn::InitVpnCustomPromptOptionSelector(target);
      NodeRT::Windows::Networking::Vpn::InitVpnCustomTextBox(target);
      NodeRT::Windows::Networking::Vpn::InitVpnCustomPromptText(target);
      NodeRT::Windows::Networking::Vpn::InitVpnCustomCheckBox(target);
      NodeRT::Windows::Networking::Vpn::InitVpnCustomPromptBooleanInput(target);
      NodeRT::Windows::Networking::Vpn::InitVpnCustomErrorBox(target);
      NodeRT::Windows::Networking::Vpn::InitVpnPlugInProfile(target);
      NodeRT::Windows::Networking::Vpn::InitVpnNativeProfile(target);
      NodeRT::Windows::Networking::Vpn::InitVpnManagementAgent(target);


  NodeRT::Utils::RegisterNameSpace("Windows.Networking.Vpn", target);
}



NODE_MODULE(binding, init)