// 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 NetworkOperators { 
  v8::Local<v8::Value> WrapMobileBroadbandAccount(::Windows::Networking::NetworkOperators::MobileBroadbandAccount^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandAccount^ UnwrapMobileBroadbandAccount(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandNetwork(::Windows::Networking::NetworkOperators::MobileBroadbandNetwork^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandNetwork^ UnwrapMobileBroadbandNetwork(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandDeviceInformation(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceInformation^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceInformation^ UnwrapMobileBroadbandDeviceInformation(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandPinManager(::Windows::Networking::NetworkOperators::MobileBroadbandPinManager^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandPinManager^ UnwrapMobileBroadbandPinManager(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandUiccApp(::Windows::Networking::NetworkOperators::MobileBroadbandUiccApp^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandUiccApp^ UnwrapMobileBroadbandUiccApp(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandCellsInfo(::Windows::Networking::NetworkOperators::MobileBroadbandCellsInfo^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandCellsInfo^ UnwrapMobileBroadbandCellsInfo(Local<Value> value);
  
  v8::Local<v8::Value> WrapNetworkOperatorDataUsageTriggerDetails(::Windows::Networking::NetworkOperators::NetworkOperatorDataUsageTriggerDetails^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::NetworkOperatorDataUsageTriggerDetails^ UnwrapNetworkOperatorDataUsageTriggerDetails(Local<Value> value);
  
  v8::Local<v8::Value> WrapTetheringEntitlementCheckTriggerDetails(::Windows::Networking::NetworkOperators::TetheringEntitlementCheckTriggerDetails^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::TetheringEntitlementCheckTriggerDetails^ UnwrapTetheringEntitlementCheckTriggerDetails(Local<Value> value);
  
  v8::Local<v8::Value> WrapNetworkOperatorTetheringAccessPointConfiguration(::Windows::Networking::NetworkOperators::NetworkOperatorTetheringAccessPointConfiguration^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::NetworkOperatorTetheringAccessPointConfiguration^ UnwrapNetworkOperatorTetheringAccessPointConfiguration(Local<Value> value);
  
  v8::Local<v8::Value> WrapNetworkOperatorTetheringOperationResult(::Windows::Networking::NetworkOperators::NetworkOperatorTetheringOperationResult^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::NetworkOperatorTetheringOperationResult^ UnwrapNetworkOperatorTetheringOperationResult(Local<Value> value);
  
  v8::Local<v8::Value> WrapNetworkOperatorTetheringManager(::Windows::Networking::NetworkOperators::NetworkOperatorTetheringManager^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::NetworkOperatorTetheringManager^ UnwrapNetworkOperatorTetheringManager(Local<Value> value);
  
  v8::Local<v8::Value> WrapNetworkOperatorTetheringClient(::Windows::Networking::NetworkOperators::NetworkOperatorTetheringClient^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::NetworkOperatorTetheringClient^ UnwrapNetworkOperatorTetheringClient(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandAccountEventArgs(::Windows::Networking::NetworkOperators::MobileBroadbandAccountEventArgs^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandAccountEventArgs^ UnwrapMobileBroadbandAccountEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandAccountUpdatedEventArgs(::Windows::Networking::NetworkOperators::MobileBroadbandAccountUpdatedEventArgs^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandAccountUpdatedEventArgs^ UnwrapMobileBroadbandAccountUpdatedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandAccountWatcher(::Windows::Networking::NetworkOperators::MobileBroadbandAccountWatcher^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandAccountWatcher^ UnwrapMobileBroadbandAccountWatcher(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandModem(::Windows::Networking::NetworkOperators::MobileBroadbandModem^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandModem^ UnwrapMobileBroadbandModem(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandUicc(::Windows::Networking::NetworkOperators::MobileBroadbandUicc^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandUicc^ UnwrapMobileBroadbandUicc(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandSarManager(::Windows::Networking::NetworkOperators::MobileBroadbandSarManager^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandSarManager^ UnwrapMobileBroadbandSarManager(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandModemConfiguration(::Windows::Networking::NetworkOperators::MobileBroadbandModemConfiguration^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandModemConfiguration^ UnwrapMobileBroadbandModemConfiguration(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandDeviceServiceInformation(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceInformation^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceInformation^ UnwrapMobileBroadbandDeviceServiceInformation(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandDeviceService(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceService^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceService^ UnwrapMobileBroadbandDeviceService(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandPco(::Windows::Networking::NetworkOperators::MobileBroadbandPco^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandPco^ UnwrapMobileBroadbandPco(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandPin(::Windows::Networking::NetworkOperators::MobileBroadbandPin^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandPin^ UnwrapMobileBroadbandPin(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandPinOperationResult(::Windows::Networking::NetworkOperators::MobileBroadbandPinOperationResult^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandPinOperationResult^ UnwrapMobileBroadbandPinOperationResult(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandDeviceServiceDataSession(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceDataSession^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceDataSession^ UnwrapMobileBroadbandDeviceServiceDataSession(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandDeviceServiceCommandSession(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandSession^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandSession^ UnwrapMobileBroadbandDeviceServiceCommandSession(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandDeviceServiceDataReceivedEventArgs(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceDataReceivedEventArgs^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceDataReceivedEventArgs^ UnwrapMobileBroadbandDeviceServiceDataReceivedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandDeviceServiceCommandResult(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandResult^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandResult^ UnwrapMobileBroadbandDeviceServiceCommandResult(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandUiccAppsResult(::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppsResult^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppsResult^ UnwrapMobileBroadbandUiccAppsResult(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandUiccAppRecordDetailsResult(::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppRecordDetailsResult^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppRecordDetailsResult^ UnwrapMobileBroadbandUiccAppRecordDetailsResult(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandUiccAppReadRecordResult(::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppReadRecordResult^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppReadRecordResult^ UnwrapMobileBroadbandUiccAppReadRecordResult(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandNetworkRegistrationStateChange(::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChange^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChange^ UnwrapMobileBroadbandNetworkRegistrationStateChange(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandNetworkRegistrationStateChangeTriggerDetails(::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChangeTriggerDetails^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChangeTriggerDetails^ UnwrapMobileBroadbandNetworkRegistrationStateChangeTriggerDetails(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandRadioStateChange(::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChange^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChange^ UnwrapMobileBroadbandRadioStateChange(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandRadioStateChangeTriggerDetails(::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChangeTriggerDetails^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChangeTriggerDetails^ UnwrapMobileBroadbandRadioStateChangeTriggerDetails(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandPinLockStateChange(::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChange^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChange^ UnwrapMobileBroadbandPinLockStateChange(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandPinLockStateChangeTriggerDetails(::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChangeTriggerDetails^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChangeTriggerDetails^ UnwrapMobileBroadbandPinLockStateChangeTriggerDetails(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandDeviceServiceTriggerDetails(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceTriggerDetails^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceTriggerDetails^ UnwrapMobileBroadbandDeviceServiceTriggerDetails(Local<Value> value);
  
  v8::Local<v8::Value> WrapKnownCSimFilePaths(::Windows::Networking::NetworkOperators::KnownCSimFilePaths^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::KnownCSimFilePaths^ UnwrapKnownCSimFilePaths(Local<Value> value);
  
  v8::Local<v8::Value> WrapKnownRuimFilePaths(::Windows::Networking::NetworkOperators::KnownRuimFilePaths^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::KnownRuimFilePaths^ UnwrapKnownRuimFilePaths(Local<Value> value);
  
  v8::Local<v8::Value> WrapKnownSimFilePaths(::Windows::Networking::NetworkOperators::KnownSimFilePaths^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::KnownSimFilePaths^ UnwrapKnownSimFilePaths(Local<Value> value);
  
  v8::Local<v8::Value> WrapKnownUSimFilePaths(::Windows::Networking::NetworkOperators::KnownUSimFilePaths^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::KnownUSimFilePaths^ UnwrapKnownUSimFilePaths(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandCellCdma(::Windows::Networking::NetworkOperators::MobileBroadbandCellCdma^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandCellCdma^ UnwrapMobileBroadbandCellCdma(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandCellGsm(::Windows::Networking::NetworkOperators::MobileBroadbandCellGsm^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandCellGsm^ UnwrapMobileBroadbandCellGsm(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandCellLte(::Windows::Networking::NetworkOperators::MobileBroadbandCellLte^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandCellLte^ UnwrapMobileBroadbandCellLte(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandCellTdscdma(::Windows::Networking::NetworkOperators::MobileBroadbandCellTdscdma^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandCellTdscdma^ UnwrapMobileBroadbandCellTdscdma(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandCellUmts(::Windows::Networking::NetworkOperators::MobileBroadbandCellUmts^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandCellUmts^ UnwrapMobileBroadbandCellUmts(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandModemIsolation(::Windows::Networking::NetworkOperators::MobileBroadbandModemIsolation^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandModemIsolation^ UnwrapMobileBroadbandModemIsolation(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandPcoDataChangeTriggerDetails(::Windows::Networking::NetworkOperators::MobileBroadbandPcoDataChangeTriggerDetails^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandPcoDataChangeTriggerDetails^ UnwrapMobileBroadbandPcoDataChangeTriggerDetails(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandAntennaSar(::Windows::Networking::NetworkOperators::MobileBroadbandAntennaSar^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandAntennaSar^ UnwrapMobileBroadbandAntennaSar(Local<Value> value);
  
  v8::Local<v8::Value> WrapMobileBroadbandTransmissionStateChangedEventArgs(::Windows::Networking::NetworkOperators::MobileBroadbandTransmissionStateChangedEventArgs^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::MobileBroadbandTransmissionStateChangedEventArgs^ UnwrapMobileBroadbandTransmissionStateChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapESimPolicy(::Windows::Networking::NetworkOperators::ESimPolicy^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::ESimPolicy^ UnwrapESimPolicy(Local<Value> value);
  
  v8::Local<v8::Value> WrapESimProfile(::Windows::Networking::NetworkOperators::ESimProfile^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::ESimProfile^ UnwrapESimProfile(Local<Value> value);
  
  v8::Local<v8::Value> WrapESimOperationResult(::Windows::Networking::NetworkOperators::ESimOperationResult^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::ESimOperationResult^ UnwrapESimOperationResult(Local<Value> value);
  
  v8::Local<v8::Value> WrapESimDownloadProfileMetadataResult(::Windows::Networking::NetworkOperators::ESimDownloadProfileMetadataResult^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::ESimDownloadProfileMetadataResult^ UnwrapESimDownloadProfileMetadataResult(Local<Value> value);
  
  v8::Local<v8::Value> WrapESim(::Windows::Networking::NetworkOperators::ESim^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::ESim^ UnwrapESim(Local<Value> value);
  
  v8::Local<v8::Value> WrapESimAddedEventArgs(::Windows::Networking::NetworkOperators::ESimAddedEventArgs^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::ESimAddedEventArgs^ UnwrapESimAddedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapESimProfileMetadata(::Windows::Networking::NetworkOperators::ESimProfileMetadata^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::ESimProfileMetadata^ UnwrapESimProfileMetadata(Local<Value> value);
  
  v8::Local<v8::Value> WrapESimServiceInfo(::Windows::Networking::NetworkOperators::ESimServiceInfo^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::ESimServiceInfo^ UnwrapESimServiceInfo(Local<Value> value);
  
  v8::Local<v8::Value> WrapESimWatcher(::Windows::Networking::NetworkOperators::ESimWatcher^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::ESimWatcher^ UnwrapESimWatcher(Local<Value> value);
  
  v8::Local<v8::Value> WrapESimManager(::Windows::Networking::NetworkOperators::ESimManager^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::ESimManager^ UnwrapESimManager(Local<Value> value);
  
  v8::Local<v8::Value> WrapESimProfilePolicy(::Windows::Networking::NetworkOperators::ESimProfilePolicy^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::ESimProfilePolicy^ UnwrapESimProfilePolicy(Local<Value> value);
  
  v8::Local<v8::Value> WrapESimRemovedEventArgs(::Windows::Networking::NetworkOperators::ESimRemovedEventArgs^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::ESimRemovedEventArgs^ UnwrapESimRemovedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapESimUpdatedEventArgs(::Windows::Networking::NetworkOperators::ESimUpdatedEventArgs^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::ESimUpdatedEventArgs^ UnwrapESimUpdatedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapHotspotAuthenticationEventDetails(::Windows::Networking::NetworkOperators::HotspotAuthenticationEventDetails^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::HotspotAuthenticationEventDetails^ UnwrapHotspotAuthenticationEventDetails(Local<Value> value);
  
  v8::Local<v8::Value> WrapHotspotAuthenticationContext(::Windows::Networking::NetworkOperators::HotspotAuthenticationContext^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::HotspotAuthenticationContext^ UnwrapHotspotAuthenticationContext(Local<Value> value);
  
  v8::Local<v8::Value> WrapHotspotCredentialsAuthenticationResult(::Windows::Networking::NetworkOperators::HotspotCredentialsAuthenticationResult^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::HotspotCredentialsAuthenticationResult^ UnwrapHotspotCredentialsAuthenticationResult(Local<Value> value);
  
  v8::Local<v8::Value> WrapProvisionFromXmlDocumentResults(::Windows::Networking::NetworkOperators::ProvisionFromXmlDocumentResults^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::ProvisionFromXmlDocumentResults^ UnwrapProvisionFromXmlDocumentResults(Local<Value> value);
  
  v8::Local<v8::Value> WrapProvisionedProfile(::Windows::Networking::NetworkOperators::ProvisionedProfile^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::ProvisionedProfile^ UnwrapProvisionedProfile(Local<Value> value);
  
  v8::Local<v8::Value> WrapProvisioningAgent(::Windows::Networking::NetworkOperators::ProvisioningAgent^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::ProvisioningAgent^ UnwrapProvisioningAgent(Local<Value> value);
  
  v8::Local<v8::Value> WrapUssdMessage(::Windows::Networking::NetworkOperators::UssdMessage^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::UssdMessage^ UnwrapUssdMessage(Local<Value> value);
  
  v8::Local<v8::Value> WrapUssdReply(::Windows::Networking::NetworkOperators::UssdReply^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::UssdReply^ UnwrapUssdReply(Local<Value> value);
  
  v8::Local<v8::Value> WrapUssdSession(::Windows::Networking::NetworkOperators::UssdSession^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::UssdSession^ UnwrapUssdSession(Local<Value> value);
  
  v8::Local<v8::Value> WrapNetworkOperatorNotificationEventDetails(::Windows::Networking::NetworkOperators::NetworkOperatorNotificationEventDetails^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::NetworkOperatorNotificationEventDetails^ UnwrapNetworkOperatorNotificationEventDetails(Local<Value> value);
  
  v8::Local<v8::Value> WrapFdnAccessManager(::Windows::Networking::NetworkOperators::FdnAccessManager^ wintRtInstance);
  ::Windows::Networking::NetworkOperators::FdnAccessManager^ UnwrapFdnAccessManager(Local<Value> value);
  



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

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

    Nan::Set(exports, Nan::New<String>("DataClasses").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::DataClasses::None)));
    Nan::Set(enumObject, Nan::New<String>("gprs").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::DataClasses::Gprs)));
    Nan::Set(enumObject, Nan::New<String>("edge").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::DataClasses::Edge)));
    Nan::Set(enumObject, Nan::New<String>("umts").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::DataClasses::Umts)));
    Nan::Set(enumObject, Nan::New<String>("hsdpa").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::DataClasses::Hsdpa)));
    Nan::Set(enumObject, Nan::New<String>("hsupa").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::DataClasses::Hsupa)));
    Nan::Set(enumObject, Nan::New<String>("lteAdvanced").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::DataClasses::LteAdvanced)));
    Nan::Set(enumObject, Nan::New<String>("cdma1xRtt").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::DataClasses::Cdma1xRtt)));
    Nan::Set(enumObject, Nan::New<String>("cdma1xEvdo").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::DataClasses::Cdma1xEvdo)));
    Nan::Set(enumObject, Nan::New<String>("cdma1xEvdoRevA").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::DataClasses::Cdma1xEvdoRevA)));
    Nan::Set(enumObject, Nan::New<String>("cdma1xEvdv").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::DataClasses::Cdma1xEvdv)));
    Nan::Set(enumObject, Nan::New<String>("cdma3xRtt").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::DataClasses::Cdma3xRtt)));
    Nan::Set(enumObject, Nan::New<String>("cdma1xEvdoRevB").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::DataClasses::Cdma1xEvdoRevB)));
    Nan::Set(enumObject, Nan::New<String>("cdmaUmb").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::DataClasses::CdmaUmb)));
    Nan::Set(enumObject, Nan::New<String>("custom").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::DataClasses::Custom)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("MobileBroadbandDeviceType").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("unknown").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceType::Unknown)));
    Nan::Set(enumObject, Nan::New<String>("embedded").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceType::Embedded)));
    Nan::Set(enumObject, Nan::New<String>("removable").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceType::Removable)));
    Nan::Set(enumObject, Nan::New<String>("remote").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceType::Remote)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("NetworkDeviceStatus").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("deviceNotReady").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkDeviceStatus::DeviceNotReady)));
    Nan::Set(enumObject, Nan::New<String>("deviceReady").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkDeviceStatus::DeviceReady)));
    Nan::Set(enumObject, Nan::New<String>("simNotInserted").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkDeviceStatus::SimNotInserted)));
    Nan::Set(enumObject, Nan::New<String>("badSim").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkDeviceStatus::BadSim)));
    Nan::Set(enumObject, Nan::New<String>("deviceHardwareFailure").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkDeviceStatus::DeviceHardwareFailure)));
    Nan::Set(enumObject, Nan::New<String>("accountNotActivated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkDeviceStatus::AccountNotActivated)));
    Nan::Set(enumObject, Nan::New<String>("deviceLocked").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkDeviceStatus::DeviceLocked)));
    Nan::Set(enumObject, Nan::New<String>("deviceBlocked").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkDeviceStatus::DeviceBlocked)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("NetworkRegistrationState").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkRegistrationState::None)));
    Nan::Set(enumObject, Nan::New<String>("deregistered").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkRegistrationState::Deregistered)));
    Nan::Set(enumObject, Nan::New<String>("searching").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkRegistrationState::Searching)));
    Nan::Set(enumObject, Nan::New<String>("home").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkRegistrationState::Home)));
    Nan::Set(enumObject, Nan::New<String>("roaming").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkRegistrationState::Roaming)));
    Nan::Set(enumObject, Nan::New<String>("partner").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkRegistrationState::Partner)));
    Nan::Set(enumObject, Nan::New<String>("denied").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkRegistrationState::Denied)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("MobileBroadbandRadioState").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("off").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandRadioState::Off)));
    Nan::Set(enumObject, Nan::New<String>("on").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandRadioState::On)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("NetworkOperatorDataUsageNotificationKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("dataUsageProgress").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkOperatorDataUsageNotificationKind::DataUsageProgress)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("NetworkOperatorEventMessageType").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("gsm").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkOperatorEventMessageType::Gsm)));
    Nan::Set(enumObject, Nan::New<String>("cdma").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkOperatorEventMessageType::Cdma)));
    Nan::Set(enumObject, Nan::New<String>("ussd").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkOperatorEventMessageType::Ussd)));
    Nan::Set(enumObject, Nan::New<String>("dataPlanThresholdReached").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkOperatorEventMessageType::DataPlanThresholdReached)));
    Nan::Set(enumObject, Nan::New<String>("dataPlanReset").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkOperatorEventMessageType::DataPlanReset)));
    Nan::Set(enumObject, Nan::New<String>("dataPlanDeleted").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkOperatorEventMessageType::DataPlanDeleted)));
    Nan::Set(enumObject, Nan::New<String>("profileConnected").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkOperatorEventMessageType::ProfileConnected)));
    Nan::Set(enumObject, Nan::New<String>("profileDisconnected").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkOperatorEventMessageType::ProfileDisconnected)));
    Nan::Set(enumObject, Nan::New<String>("registeredRoaming").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkOperatorEventMessageType::RegisteredRoaming)));
    Nan::Set(enumObject, Nan::New<String>("registeredHome").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkOperatorEventMessageType::RegisteredHome)));
    Nan::Set(enumObject, Nan::New<String>("tetheringEntitlementCheck").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkOperatorEventMessageType::TetheringEntitlementCheck)));
    Nan::Set(enumObject, Nan::New<String>("tetheringOperationalStateChanged").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkOperatorEventMessageType::TetheringOperationalStateChanged)));
    Nan::Set(enumObject, Nan::New<String>("tetheringNumberOfClientsChanged").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::NetworkOperatorEventMessageType::TetheringNumberOfClientsChanged)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("MobileBroadbandAccountWatcherStatus").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("created").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandAccountWatcherStatus::Created)));
    Nan::Set(enumObject, Nan::New<String>("started").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandAccountWatcherStatus::Started)));
    Nan::Set(enumObject, Nan::New<String>("enumerationCompleted").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandAccountWatcherStatus::EnumerationCompleted)));
    Nan::Set(enumObject, Nan::New<String>("stopped").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandAccountWatcherStatus::Stopped)));
    Nan::Set(enumObject, Nan::New<String>("aborted").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandAccountWatcherStatus::Aborted)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("TetheringOperationalState").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("unknown").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::TetheringOperationalState::Unknown)));
    Nan::Set(enumObject, Nan::New<String>("on").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::TetheringOperationalState::On)));
    Nan::Set(enumObject, Nan::New<String>("off").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::TetheringOperationalState::Off)));
    Nan::Set(enumObject, Nan::New<String>("inTransition").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::TetheringOperationalState::InTransition)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("TetheringCapability").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("enabled").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::TetheringCapability::Enabled)));
    Nan::Set(enumObject, Nan::New<String>("disabledByGroupPolicy").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::TetheringCapability::DisabledByGroupPolicy)));
    Nan::Set(enumObject, Nan::New<String>("disabledByHardwareLimitation").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::TetheringCapability::DisabledByHardwareLimitation)));
    Nan::Set(enumObject, Nan::New<String>("disabledByOperator").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::TetheringCapability::DisabledByOperator)));
    Nan::Set(enumObject, Nan::New<String>("disabledBySku").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::TetheringCapability::DisabledBySku)));
    Nan::Set(enumObject, Nan::New<String>("disabledByRequiredAppNotInstalled").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::TetheringCapability::DisabledByRequiredAppNotInstalled)));
    Nan::Set(enumObject, Nan::New<String>("disabledDueToUnknownCause").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::TetheringCapability::DisabledDueToUnknownCause)));
    Nan::Set(enumObject, Nan::New<String>("disabledBySystemCapability").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::TetheringCapability::DisabledBySystemCapability)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("TetheringOperationStatus").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("success").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::TetheringOperationStatus::Success)));
    Nan::Set(enumObject, Nan::New<String>("unknown").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::TetheringOperationStatus::Unknown)));
    Nan::Set(enumObject, Nan::New<String>("mobileBroadbandDeviceOff").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::TetheringOperationStatus::MobileBroadbandDeviceOff)));
    Nan::Set(enumObject, Nan::New<String>("wiFiDeviceOff").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::TetheringOperationStatus::WiFiDeviceOff)));
    Nan::Set(enumObject, Nan::New<String>("entitlementCheckTimeout").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::TetheringOperationStatus::EntitlementCheckTimeout)));
    Nan::Set(enumObject, Nan::New<String>("entitlementCheckFailure").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::TetheringOperationStatus::EntitlementCheckFailure)));
    Nan::Set(enumObject, Nan::New<String>("operationInProgress").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::TetheringOperationStatus::OperationInProgress)));
    Nan::Set(enumObject, Nan::New<String>("bluetoothDeviceOff").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::TetheringOperationStatus::BluetoothDeviceOff)));
    Nan::Set(enumObject, Nan::New<String>("networkLimitedConnectivity").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::TetheringOperationStatus::NetworkLimitedConnectivity)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("MobileBroadbandPinLockState").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("unknown").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandPinLockState::Unknown)));
    Nan::Set(enumObject, Nan::New<String>("unlocked").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandPinLockState::Unlocked)));
    Nan::Set(enumObject, Nan::New<String>("pinRequired").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandPinLockState::PinRequired)));
    Nan::Set(enumObject, Nan::New<String>("pinUnblockKeyRequired").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandPinLockState::PinUnblockKeyRequired)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("MobileBroadbandPinType").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandPinType::None)));
    Nan::Set(enumObject, Nan::New<String>("custom").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandPinType::Custom)));
    Nan::Set(enumObject, Nan::New<String>("pin1").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandPinType::Pin1)));
    Nan::Set(enumObject, Nan::New<String>("pin2").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandPinType::Pin2)));
    Nan::Set(enumObject, Nan::New<String>("simPin").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandPinType::SimPin)));
    Nan::Set(enumObject, Nan::New<String>("firstSimPin").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandPinType::FirstSimPin)));
    Nan::Set(enumObject, Nan::New<String>("networkPin").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandPinType::NetworkPin)));
    Nan::Set(enumObject, Nan::New<String>("networkSubsetPin").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandPinType::NetworkSubsetPin)));
    Nan::Set(enumObject, Nan::New<String>("serviceProviderPin").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandPinType::ServiceProviderPin)));
    Nan::Set(enumObject, Nan::New<String>("corporatePin").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandPinType::CorporatePin)));
    Nan::Set(enumObject, Nan::New<String>("subsidyLock").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandPinType::SubsidyLock)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("MobileBroadbandPinFormat").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("unknown").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandPinFormat::Unknown)));
    Nan::Set(enumObject, Nan::New<String>("numeric").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandPinFormat::Numeric)));
    Nan::Set(enumObject, Nan::New<String>("alphanumeric").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandPinFormat::Alphanumeric)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("MobileBroadbandUiccAppOperationStatus").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("success").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppOperationStatus::Success)));
    Nan::Set(enumObject, Nan::New<String>("invalidUiccFilePath").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppOperationStatus::InvalidUiccFilePath)));
    Nan::Set(enumObject, Nan::New<String>("accessConditionNotHeld").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppOperationStatus::AccessConditionNotHeld)));
    Nan::Set(enumObject, Nan::New<String>("uiccBusy").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppOperationStatus::UiccBusy)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("UiccAppKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("unknown").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::UiccAppKind::Unknown)));
    Nan::Set(enumObject, Nan::New<String>("mF").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::UiccAppKind::MF)));
    Nan::Set(enumObject, Nan::New<String>("mFSim").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::UiccAppKind::MFSim)));
    Nan::Set(enumObject, Nan::New<String>("mFRuim").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::UiccAppKind::MFRuim)));
    Nan::Set(enumObject, Nan::New<String>("uSim").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::UiccAppKind::USim)));
    Nan::Set(enumObject, Nan::New<String>("cSim").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::UiccAppKind::CSim)));
    Nan::Set(enumObject, Nan::New<String>("iSim").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::UiccAppKind::ISim)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("UiccAppRecordKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("unknown").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::UiccAppRecordKind::Unknown)));
    Nan::Set(enumObject, Nan::New<String>("transparent").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::UiccAppRecordKind::Transparent)));
    Nan::Set(enumObject, Nan::New<String>("recordOriented").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::UiccAppRecordKind::RecordOriented)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("UiccAccessCondition").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("alwaysAllowed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::UiccAccessCondition::AlwaysAllowed)));
    Nan::Set(enumObject, Nan::New<String>("pin1").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::UiccAccessCondition::Pin1)));
    Nan::Set(enumObject, Nan::New<String>("pin2").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::UiccAccessCondition::Pin2)));
    Nan::Set(enumObject, Nan::New<String>("pin3").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::UiccAccessCondition::Pin3)));
    Nan::Set(enumObject, Nan::New<String>("pin4").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::UiccAccessCondition::Pin4)));
    Nan::Set(enumObject, Nan::New<String>("administrative5").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::UiccAccessCondition::Administrative5)));
    Nan::Set(enumObject, Nan::New<String>("administrative6").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::UiccAccessCondition::Administrative6)));
    Nan::Set(enumObject, Nan::New<String>("neverAllowed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::UiccAccessCondition::NeverAllowed)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("MobileBroadbandModemStatus").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("success").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandModemStatus::Success)));
    Nan::Set(enumObject, Nan::New<String>("otherFailure").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandModemStatus::OtherFailure)));
    Nan::Set(enumObject, Nan::New<String>("busy").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandModemStatus::Busy)));
    Nan::Set(enumObject, Nan::New<String>("noDeviceSupport").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::MobileBroadbandModemStatus::NoDeviceSupport)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ESimAuthenticationPreference").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("onEntry").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimAuthenticationPreference::OnEntry)));
    Nan::Set(enumObject, Nan::New<String>("onAction").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimAuthenticationPreference::OnAction)));
    Nan::Set(enumObject, Nan::New<String>("never").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimAuthenticationPreference::Never)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ESimProfileClass").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("operational").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimProfileClass::Operational)));
    Nan::Set(enumObject, Nan::New<String>("test").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimProfileClass::Test)));
    Nan::Set(enumObject, Nan::New<String>("provisioning").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimProfileClass::Provisioning)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ESimOperationStatus").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("success").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimOperationStatus::Success)));
    Nan::Set(enumObject, Nan::New<String>("notAuthorized").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimOperationStatus::NotAuthorized)));
    Nan::Set(enumObject, Nan::New<String>("notFound").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimOperationStatus::NotFound)));
    Nan::Set(enumObject, Nan::New<String>("policyViolation").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimOperationStatus::PolicyViolation)));
    Nan::Set(enumObject, Nan::New<String>("insufficientSpaceOnCard").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimOperationStatus::InsufficientSpaceOnCard)));
    Nan::Set(enumObject, Nan::New<String>("serverFailure").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimOperationStatus::ServerFailure)));
    Nan::Set(enumObject, Nan::New<String>("serverNotReachable").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimOperationStatus::ServerNotReachable)));
    Nan::Set(enumObject, Nan::New<String>("timeoutWaitingForUserConsent").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimOperationStatus::TimeoutWaitingForUserConsent)));
    Nan::Set(enumObject, Nan::New<String>("incorrectConfirmationCode").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimOperationStatus::IncorrectConfirmationCode)));
    Nan::Set(enumObject, Nan::New<String>("confirmationCodeMaxRetriesExceeded").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimOperationStatus::ConfirmationCodeMaxRetriesExceeded)));
    Nan::Set(enumObject, Nan::New<String>("cardRemoved").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimOperationStatus::CardRemoved)));
    Nan::Set(enumObject, Nan::New<String>("cardBusy").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimOperationStatus::CardBusy)));
    Nan::Set(enumObject, Nan::New<String>("other").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimOperationStatus::Other)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ESimProfileMetadataState").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("unknown").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimProfileMetadataState::Unknown)));
    Nan::Set(enumObject, Nan::New<String>("waitingForInstall").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimProfileMetadataState::WaitingForInstall)));
    Nan::Set(enumObject, Nan::New<String>("downloading").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimProfileMetadataState::Downloading)));
    Nan::Set(enumObject, Nan::New<String>("installing").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimProfileMetadataState::Installing)));
    Nan::Set(enumObject, Nan::New<String>("expired").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimProfileMetadataState::Expired)));
    Nan::Set(enumObject, Nan::New<String>("rejectingDownload").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimProfileMetadataState::RejectingDownload)));
    Nan::Set(enumObject, Nan::New<String>("noLongerAvailable").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimProfileMetadataState::NoLongerAvailable)));
    Nan::Set(enumObject, Nan::New<String>("deniedByPolicy").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimProfileMetadataState::DeniedByPolicy)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ESimProfileState").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("unknown").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimProfileState::Unknown)));
    Nan::Set(enumObject, Nan::New<String>("disabled").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimProfileState::Disabled)));
    Nan::Set(enumObject, Nan::New<String>("enabled").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimProfileState::Enabled)));
    Nan::Set(enumObject, Nan::New<String>("deleted").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimProfileState::Deleted)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ESimState").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("unknown").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimState::Unknown)));
    Nan::Set(enumObject, Nan::New<String>("idle").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimState::Idle)));
    Nan::Set(enumObject, Nan::New<String>("removed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimState::Removed)));
    Nan::Set(enumObject, Nan::New<String>("busy").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimState::Busy)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ESimWatcherStatus").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("created").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimWatcherStatus::Created)));
    Nan::Set(enumObject, Nan::New<String>("started").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimWatcherStatus::Started)));
    Nan::Set(enumObject, Nan::New<String>("enumerationCompleted").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimWatcherStatus::EnumerationCompleted)));
    Nan::Set(enumObject, Nan::New<String>("stopping").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimWatcherStatus::Stopping)));
    Nan::Set(enumObject, Nan::New<String>("stopped").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ESimWatcherStatus::Stopped)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("HotspotAuthenticationResponseCode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("noError").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::HotspotAuthenticationResponseCode::NoError)));
    Nan::Set(enumObject, Nan::New<String>("loginSucceeded").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::HotspotAuthenticationResponseCode::LoginSucceeded)));
    Nan::Set(enumObject, Nan::New<String>("loginFailed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::HotspotAuthenticationResponseCode::LoginFailed)));
    Nan::Set(enumObject, Nan::New<String>("radiusServerError").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::HotspotAuthenticationResponseCode::RadiusServerError)));
    Nan::Set(enumObject, Nan::New<String>("networkAdministratorError").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::HotspotAuthenticationResponseCode::NetworkAdministratorError)));
    Nan::Set(enumObject, Nan::New<String>("loginAborted").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::HotspotAuthenticationResponseCode::LoginAborted)));
    Nan::Set(enumObject, Nan::New<String>("accessGatewayInternalError").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::HotspotAuthenticationResponseCode::AccessGatewayInternalError)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ProfileMediaType").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("wlan").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ProfileMediaType::Wlan)));
    Nan::Set(enumObject, Nan::New<String>("wwan").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::ProfileMediaType::Wwan)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("UssdResultCode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("noActionRequired").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::UssdResultCode::NoActionRequired)));
    Nan::Set(enumObject, Nan::New<String>("actionRequired").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::UssdResultCode::ActionRequired)));
    Nan::Set(enumObject, Nan::New<String>("terminated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::UssdResultCode::Terminated)));
    Nan::Set(enumObject, Nan::New<String>("otherLocalClient").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::UssdResultCode::OtherLocalClient)));
    Nan::Set(enumObject, Nan::New<String>("operationNotSupported").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::UssdResultCode::OperationNotSupported)));
    Nan::Set(enumObject, Nan::New<String>("networkTimeout").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Networking::NetworkOperators::UssdResultCode::NetworkTimeout)));
  }

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

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

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

  ::Windows::Networking::NetworkOperators::ESimProfileInstallProgress ESimProfileInstallProgressFromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::Networking::NetworkOperators::ESimProfileInstallProgress returnValue;

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

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

    symbol = Nan::New<String>("totalSizeInBytes").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.TotalSizeInBytes = static_cast<int>(Nan::To<int32_t>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0));
    }
    
    symbol = Nan::New<String>("installedSizeInBytes").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.InstalledSizeInBytes = static_cast<int>(Nan::To<int32_t>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0));
    }
    
    return returnValue;
  }

  Local<Value> ESimProfileInstallProgressToJsObject(::Windows::Networking::NetworkOperators::ESimProfileInstallProgress value) {
    EscapableHandleScope scope;

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

    Nan::Set(obj, Nan::New<String>("totalSizeInBytes").ToLocalChecked(), Nan::New<Integer>(value.TotalSizeInBytes));
    Nan::Set(obj, Nan::New<String>("installedSizeInBytes").ToLocalChecked(), Nan::New<Integer>(value.InstalledSizeInBytes));

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

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

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

  ::Windows::Networking::NetworkOperators::ProfileUsage ProfileUsageFromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::Networking::NetworkOperators::ProfileUsage returnValue;

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

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

    symbol = Nan::New<String>("usageInMegabytes").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.UsageInMegabytes = static_cast<unsigned int>(Nan::To<uint32_t>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0));
    }
    
    symbol = Nan::New<String>("lastSyncTime").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.LastSyncTime = NodeRT::Utils::DateTimeFromJSDate(Nan::Get(obj,symbol).ToLocalChecked());
    }
    
    return returnValue;
  }

  Local<Value> ProfileUsageToJsObject(::Windows::Networking::NetworkOperators::ProfileUsage value) {
    EscapableHandleScope scope;

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

    Nan::Set(obj, Nan::New<String>("usageInMegabytes").ToLocalChecked(), Nan::New<Integer>(value.UsageInMegabytes));
    Nan::Set(obj, Nan::New<String>("lastSyncTime").ToLocalChecked(), NodeRT::Utils::DateTimeToJS(value.LastSyncTime));

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

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

    return true;
  }

  ::Windows::Networking::NetworkOperators::LegacyNetworkOperatorsContract LegacyNetworkOperatorsContractFromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::Networking::NetworkOperators::LegacyNetworkOperatorsContract returnValue;

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

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

    return returnValue;
  }

  Local<Value> LegacyNetworkOperatorsContractToJsObject(::Windows::Networking::NetworkOperators::LegacyNetworkOperatorsContract value) {
    EscapableHandleScope scope;

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


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

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

    return true;
  }

  ::Windows::Networking::NetworkOperators::NetworkOperatorsFdnContract NetworkOperatorsFdnContractFromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::Networking::NetworkOperators::NetworkOperatorsFdnContract returnValue;

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

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

    return returnValue;
  }

  Local<Value> NetworkOperatorsFdnContractToJsObject(::Windows::Networking::NetworkOperators::NetworkOperatorsFdnContract value) {
    EscapableHandleScope scope;

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


    return scope.Escape(obj);
  }


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


          
            Nan::SetPrototypeMethod(localRef, "getConnectionProfiles", GetConnectionProfiles);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("currentDeviceInformation").ToLocalChecked(), CurrentDeviceInformationGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("currentNetwork").ToLocalChecked(), CurrentNetworkGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("networkAccountId").ToLocalChecked(), NetworkAccountIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("serviceProviderGuid").ToLocalChecked(), ServiceProviderGuidGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("serviceProviderName").ToLocalChecked(), ServiceProviderNameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("accountExperienceUrl").ToLocalChecked(), AccountExperienceUrlGetter);

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

        Nan::SetMethod(constructor, "createFromNetworkAccountId", CreateFromNetworkAccountId);
        Nan::SetAccessor(constructor, Nan::New<String>("availableNetworkAccountIds").ToLocalChecked(), AvailableNetworkAccountIdsGetter);


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

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

    private:

      MobileBroadbandAccount(::Windows::Networking::NetworkOperators::MobileBroadbandAccount^ 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::NetworkOperators::MobileBroadbandAccount^ winRtInstance;


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

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

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


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

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

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

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



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

      if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          ::Windows::Networking::NetworkOperators::MobileBroadbandAccount^ result;
          result = ::Windows::Networking::NetworkOperators::MobileBroadbandAccount::CreateFromNetworkAccountId(arg0);
          info.GetReturnValue().Set(WrapMobileBroadbandAccount(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 CurrentDeviceInformationGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

      try
      {
        ::Windows::Foundation::Collections::IVectorView<::Platform::String^>^ result = ::Windows::Networking::NetworkOperators::MobileBroadbandAccount::AvailableNetworkAccountIds;
        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;
      }
    }
      

    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandAccount^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandAccount(::Windows::Networking::NetworkOperators::MobileBroadbandAccount^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandAccount^ UnwrapMobileBroadbandAccount(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandAccount::s_constructorTemplate;

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

  ::Windows::Networking::NetworkOperators::MobileBroadbandAccount^ UnwrapMobileBroadbandAccount(Local<Value> value) {
     return MobileBroadbandAccount::Unwrap<MobileBroadbandAccount>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandAccount(Local<Object> exports) {
    MobileBroadbandAccount::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "showConnectionUI", ShowConnectionUI);
          

          
            Nan::SetPrototypeMethod(localRef, "getVoiceCallSupportAsync", GetVoiceCallSupportAsync);
            Nan::SetPrototypeMethod(localRef, "getCellsInfoAsync", GetCellsInfoAsync);
          


          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("accessPointName").ToLocalChecked(), AccessPointNameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("activationNetworkError").ToLocalChecked(), ActivationNetworkErrorGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("networkAdapter").ToLocalChecked(), NetworkAdapterGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("networkRegistrationState").ToLocalChecked(), NetworkRegistrationStateGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("packetAttachNetworkError").ToLocalChecked(), PacketAttachNetworkErrorGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("registeredDataClass").ToLocalChecked(), RegisteredDataClassGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("registeredProviderId").ToLocalChecked(), RegisteredProviderIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("registeredProviderName").ToLocalChecked(), RegisteredProviderNameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("registrationNetworkError").ToLocalChecked(), RegistrationNetworkErrorGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("registrationUiccApps").ToLocalChecked(), RegistrationUiccAppsGetter);

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



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

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

    private:

      MobileBroadbandNetwork(::Windows::Networking::NetworkOperators::MobileBroadbandNetwork^ 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::NetworkOperators::MobileBroadbandNetwork^ winRtInstance;


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

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

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

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

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

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

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


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

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::NetworkOperators::MobileBroadbandCellsInfo^>^ op;


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::NetworkOperators::MobileBroadbandUiccApp^>^ result = wrapper->_instance->RegistrationUiccApps;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Networking::NetworkOperators::MobileBroadbandUiccApp^>::CreateVectorViewWrapper(result, 
            [](::Windows::Networking::NetworkOperators::MobileBroadbandUiccApp^ val) -> Local<Value> {
              return WrapMobileBroadbandUiccApp(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandUiccApp^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::NetworkOperators::MobileBroadbandUiccApp^ {
              return UnwrapMobileBroadbandUiccApp(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandNetwork^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandNetwork(::Windows::Networking::NetworkOperators::MobileBroadbandNetwork^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandNetwork^ UnwrapMobileBroadbandNetwork(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandNetwork::s_constructorTemplate;

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

  ::Windows::Networking::NetworkOperators::MobileBroadbandNetwork^ UnwrapMobileBroadbandNetwork(Local<Value> value) {
     return MobileBroadbandNetwork::Unwrap<MobileBroadbandNetwork>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandNetwork(Local<Object> exports) {
    MobileBroadbandNetwork::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("cellularClass").ToLocalChecked(), CellularClassGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("currentRadioState").ToLocalChecked(), CurrentRadioStateGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("customDataClass").ToLocalChecked(), CustomDataClassGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dataClasses").ToLocalChecked(), DataClassesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("deviceId").ToLocalChecked(), DeviceIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("deviceType").ToLocalChecked(), DeviceTypeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("firmwareInformation").ToLocalChecked(), FirmwareInformationGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("manufacturer").ToLocalChecked(), ManufacturerGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("mobileEquipmentId").ToLocalChecked(), MobileEquipmentIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("model").ToLocalChecked(), ModelGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("networkDeviceStatus").ToLocalChecked(), NetworkDeviceStatusGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("simIccId").ToLocalChecked(), SimIccIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("subscriberId").ToLocalChecked(), SubscriberIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("telephoneNumbers").ToLocalChecked(), TelephoneNumbersGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pinManager").ToLocalChecked(), PinManagerGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("revision").ToLocalChecked(), RevisionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("serialNumber").ToLocalChecked(), SerialNumberGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("simGid1").ToLocalChecked(), SimGid1Getter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("simPnn").ToLocalChecked(), SimPnnGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("simSpn").ToLocalChecked(), SimSpnGetter);

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



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

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

    private:

      MobileBroadbandDeviceInformation(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceInformation^ 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::NetworkOperators::MobileBroadbandDeviceInformation^ winRtInstance;


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

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

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





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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceInformation^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandDeviceInformation(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceInformation^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceInformation^ UnwrapMobileBroadbandDeviceInformation(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandDeviceInformation::s_constructorTemplate;

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

  ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceInformation^ UnwrapMobileBroadbandDeviceInformation(Local<Value> value) {
     return MobileBroadbandDeviceInformation::Unwrap<MobileBroadbandDeviceInformation>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandDeviceInformation(Local<Object> exports) {
    MobileBroadbandDeviceInformation::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getPin", GetPin);
          



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

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



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

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

    private:

      MobileBroadbandPinManager(::Windows::Networking::NetworkOperators::MobileBroadbandPinManager^ 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::NetworkOperators::MobileBroadbandPinManager^ winRtInstance;


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

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

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


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

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

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

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::Networking::NetworkOperators::MobileBroadbandPinType arg0 = static_cast<::Windows::Networking::NetworkOperators::MobileBroadbandPinType>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          ::Windows::Networking::NetworkOperators::MobileBroadbandPin^ result;
          result = wrapper->_instance->GetPin(arg0);
          info.GetReturnValue().Set(WrapMobileBroadbandPin(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 SupportedPinsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::NetworkOperators::MobileBroadbandPinType>^ result = wrapper->_instance->SupportedPins;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Networking::NetworkOperators::MobileBroadbandPinType>::CreateVectorViewWrapper(result, 
            [](::Windows::Networking::NetworkOperators::MobileBroadbandPinType val) -> Local<Value> {
              return Nan::New<Integer>(static_cast<int>(val));
            },
            [](Local<Value> value) -> bool {
              return value->IsInt32();
            },
            [](Local<Value> value) -> ::Windows::Networking::NetworkOperators::MobileBroadbandPinType {
              return static_cast<::Windows::Networking::NetworkOperators::MobileBroadbandPinType>(Nan::To<int32_t>(value).FromMaybe(0));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandPinManager^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandPinManager(::Windows::Networking::NetworkOperators::MobileBroadbandPinManager^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandPinManager^ UnwrapMobileBroadbandPinManager(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandPinManager::s_constructorTemplate;

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

  ::Windows::Networking::NetworkOperators::MobileBroadbandPinManager^ UnwrapMobileBroadbandPinManager(Local<Value> value) {
     return MobileBroadbandPinManager::Unwrap<MobileBroadbandPinManager>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandPinManager(Local<Object> exports) {
    MobileBroadbandPinManager::Init(exports);
  }

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

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


          
            Nan::SetPrototypeMethod(localRef, "getRecordDetailsAsync", GetRecordDetailsAsync);
            Nan::SetPrototypeMethod(localRef, "readRecordAsync", ReadRecordAsync);
          


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

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



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

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

    private:

      MobileBroadbandUiccApp(::Windows::Networking::NetworkOperators::MobileBroadbandUiccApp^ 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::NetworkOperators::MobileBroadbandUiccApp^ winRtInstance;


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

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

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

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

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppRecordDetailsResult^>^ op;


      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<unsigned int>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<unsigned int>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<unsigned int>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<unsigned int>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsUint32();
                 },
                 [](Local<Value> value) -> unsigned int {
                   return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<unsigned int>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          op = wrapper->_instance->GetRecordDetailsAsync(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::NetworkOperators::MobileBroadbandUiccAppRecordDetailsResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppReadRecordResult^>^ op;


      if (info.Length() == 3
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<unsigned int>^>(info[0]) || info[0]->IsArray())
        && info[1]->IsInt32())
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<unsigned int>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<unsigned int>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<unsigned int>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return value->IsUint32();
                 },
                 [](Local<Value> value) -> unsigned int {
                   return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<unsigned int>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          int arg1 = static_cast<int>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          op = wrapper->_instance->ReadRecordAsync(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::NetworkOperators::MobileBroadbandUiccAppReadRecordResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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


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

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




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

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

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

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

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

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

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


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandUiccApp^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandUiccApp(::Windows::Networking::NetworkOperators::MobileBroadbandUiccApp^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandUiccApp^ UnwrapMobileBroadbandUiccApp(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandUiccApp::s_constructorTemplate;

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

  ::Windows::Networking::NetworkOperators::MobileBroadbandUiccApp^ UnwrapMobileBroadbandUiccApp(Local<Value> value) {
     return MobileBroadbandUiccApp::Unwrap<MobileBroadbandUiccApp>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandUiccApp(Local<Object> exports) {
    MobileBroadbandUiccApp::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("neighboringCellsCdma").ToLocalChecked(), NeighboringCellsCdmaGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("neighboringCellsGsm").ToLocalChecked(), NeighboringCellsGsmGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("neighboringCellsLte").ToLocalChecked(), NeighboringCellsLteGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("neighboringCellsTdscdma").ToLocalChecked(), NeighboringCellsTdscdmaGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("neighboringCellsUmts").ToLocalChecked(), NeighboringCellsUmtsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("servingCellsCdma").ToLocalChecked(), ServingCellsCdmaGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("servingCellsGsm").ToLocalChecked(), ServingCellsGsmGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("servingCellsLte").ToLocalChecked(), ServingCellsLteGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("servingCellsTdscdma").ToLocalChecked(), ServingCellsTdscdmaGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("servingCellsUmts").ToLocalChecked(), ServingCellsUmtsGetter);

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



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

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

    private:

      MobileBroadbandCellsInfo(::Windows::Networking::NetworkOperators::MobileBroadbandCellsInfo^ 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::NetworkOperators::MobileBroadbandCellsInfo^ winRtInstance;


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

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

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





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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::NetworkOperators::MobileBroadbandCellUmts^>^ result = wrapper->_instance->ServingCellsUmts;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Networking::NetworkOperators::MobileBroadbandCellUmts^>::CreateVectorViewWrapper(result, 
            [](::Windows::Networking::NetworkOperators::MobileBroadbandCellUmts^ val) -> Local<Value> {
              return WrapMobileBroadbandCellUmts(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellUmts^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::NetworkOperators::MobileBroadbandCellUmts^ {
              return UnwrapMobileBroadbandCellUmts(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandCellsInfo^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandCellsInfo(::Windows::Networking::NetworkOperators::MobileBroadbandCellsInfo^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandCellsInfo^ UnwrapMobileBroadbandCellsInfo(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandCellsInfo::s_constructorTemplate;

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

  ::Windows::Networking::NetworkOperators::MobileBroadbandCellsInfo^ UnwrapMobileBroadbandCellsInfo(Local<Value> value) {
     return MobileBroadbandCellsInfo::Unwrap<MobileBroadbandCellsInfo>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandCellsInfo(Local<Object> exports) {
    MobileBroadbandCellsInfo::Init(exports);
  }

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





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

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



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

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

    private:

      NetworkOperatorDataUsageTriggerDetails(::Windows::Networking::NetworkOperators::NetworkOperatorDataUsageTriggerDetails^ 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::NetworkOperators::NetworkOperatorDataUsageTriggerDetails^ winRtInstance;


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

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

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





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

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

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

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


    private:
      ::Windows::Networking::NetworkOperators::NetworkOperatorDataUsageTriggerDetails^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapNetworkOperatorDataUsageTriggerDetails(::Windows::Networking::NetworkOperators::NetworkOperatorDataUsageTriggerDetails^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::NetworkOperatorDataUsageTriggerDetails^ UnwrapNetworkOperatorDataUsageTriggerDetails(Local<Value> value);
  };

  Persistent<FunctionTemplate> NetworkOperatorDataUsageTriggerDetails::s_constructorTemplate;

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

  ::Windows::Networking::NetworkOperators::NetworkOperatorDataUsageTriggerDetails^ UnwrapNetworkOperatorDataUsageTriggerDetails(Local<Value> value) {
     return NetworkOperatorDataUsageTriggerDetails::Unwrap<NetworkOperatorDataUsageTriggerDetails>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitNetworkOperatorDataUsageTriggerDetails(Local<Object> exports) {
    NetworkOperatorDataUsageTriggerDetails::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "allowTethering", AllowTethering);
            Nan::SetPrototypeMethod(localRef, "denyTethering", DenyTethering);
          



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

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



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

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

    private:

      TetheringEntitlementCheckTriggerDetails(::Windows::Networking::NetworkOperators::TetheringEntitlementCheckTriggerDetails^ 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::NetworkOperators::TetheringEntitlementCheckTriggerDetails^ winRtInstance;


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

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

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


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

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

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

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

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

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

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

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

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


    private:
      ::Windows::Networking::NetworkOperators::TetheringEntitlementCheckTriggerDetails^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapTetheringEntitlementCheckTriggerDetails(::Windows::Networking::NetworkOperators::TetheringEntitlementCheckTriggerDetails^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::TetheringEntitlementCheckTriggerDetails^ UnwrapTetheringEntitlementCheckTriggerDetails(Local<Value> value);
  };

  Persistent<FunctionTemplate> TetheringEntitlementCheckTriggerDetails::s_constructorTemplate;

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

  ::Windows::Networking::NetworkOperators::TetheringEntitlementCheckTriggerDetails^ UnwrapTetheringEntitlementCheckTriggerDetails(Local<Value> value) {
     return TetheringEntitlementCheckTriggerDetails::Unwrap<TetheringEntitlementCheckTriggerDetails>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitTetheringEntitlementCheckTriggerDetails(Local<Object> exports) {
    TetheringEntitlementCheckTriggerDetails::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("ssid").ToLocalChecked(), SsidGetter, SsidSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("passphrase").ToLocalChecked(), PassphraseGetter, PassphraseSetter);

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



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

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

    private:

      NetworkOperatorTetheringAccessPointConfiguration(::Windows::Networking::NetworkOperators::NetworkOperatorTetheringAccessPointConfiguration^ 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::NetworkOperators::NetworkOperatorTetheringAccessPointConfiguration^ winRtInstance;


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

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

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





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

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

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

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

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

      try {

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

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

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

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

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

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

      try {

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

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


    private:
      ::Windows::Networking::NetworkOperators::NetworkOperatorTetheringAccessPointConfiguration^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapNetworkOperatorTetheringAccessPointConfiguration(::Windows::Networking::NetworkOperators::NetworkOperatorTetheringAccessPointConfiguration^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::NetworkOperatorTetheringAccessPointConfiguration^ UnwrapNetworkOperatorTetheringAccessPointConfiguration(Local<Value> value);
  };

  Persistent<FunctionTemplate> NetworkOperatorTetheringAccessPointConfiguration::s_constructorTemplate;

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

  ::Windows::Networking::NetworkOperators::NetworkOperatorTetheringAccessPointConfiguration^ UnwrapNetworkOperatorTetheringAccessPointConfiguration(Local<Value> value) {
     return NetworkOperatorTetheringAccessPointConfiguration::Unwrap<NetworkOperatorTetheringAccessPointConfiguration>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitNetworkOperatorTetheringAccessPointConfiguration(Local<Object> exports) {
    NetworkOperatorTetheringAccessPointConfiguration::Init(exports);
  }

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





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

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



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

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

    private:

      NetworkOperatorTetheringOperationResult(::Windows::Networking::NetworkOperators::NetworkOperatorTetheringOperationResult^ 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::NetworkOperators::NetworkOperatorTetheringOperationResult^ winRtInstance;


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

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

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





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

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

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

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

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

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

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


    private:
      ::Windows::Networking::NetworkOperators::NetworkOperatorTetheringOperationResult^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapNetworkOperatorTetheringOperationResult(::Windows::Networking::NetworkOperators::NetworkOperatorTetheringOperationResult^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::NetworkOperatorTetheringOperationResult^ UnwrapNetworkOperatorTetheringOperationResult(Local<Value> value);
  };

  Persistent<FunctionTemplate> NetworkOperatorTetheringOperationResult::s_constructorTemplate;

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

  ::Windows::Networking::NetworkOperators::NetworkOperatorTetheringOperationResult^ UnwrapNetworkOperatorTetheringOperationResult(Local<Value> value) {
     return NetworkOperatorTetheringOperationResult::Unwrap<NetworkOperatorTetheringOperationResult>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitNetworkOperatorTetheringOperationResult(Local<Object> exports) {
    NetworkOperatorTetheringOperationResult::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "getCurrentAccessPointConfiguration", GetCurrentAccessPointConfiguration);
            Nan::SetPrototypeMethod(localRef, "getTetheringClients", GetTetheringClients);
          

          
            Nan::SetPrototypeMethod(localRef, "configureAccessPointAsync", ConfigureAccessPointAsync);
            Nan::SetPrototypeMethod(localRef, "startTetheringAsync", StartTetheringAsync);
            Nan::SetPrototypeMethod(localRef, "stopTetheringAsync", StopTetheringAsync);
          


          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("clientCount").ToLocalChecked(), ClientCountGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxClientCount").ToLocalChecked(), MaxClientCountGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("tetheringOperationalState").ToLocalChecked(), TetheringOperationalStateGetter);

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

        Nan::SetMethod(constructor, "createFromConnectionProfile", CreateFromConnectionProfile);
        Nan::SetMethod(constructor, "getTetheringCapabilityFromConnectionProfile", GetTetheringCapabilityFromConnectionProfile);
        Nan::SetMethod(constructor, "getTetheringCapability", GetTetheringCapability);
        Nan::SetMethod(constructor, "createFromNetworkAccountId", CreateFromNetworkAccountId);


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

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

    private:

      NetworkOperatorTetheringManager(::Windows::Networking::NetworkOperators::NetworkOperatorTetheringManager^ 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::NetworkOperators::NetworkOperatorTetheringManager^ winRtInstance;


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

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

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

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

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

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

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


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::NetworkOperatorTetheringAccessPointConfiguration^>(info[0]))
      {
        try
        {
          ::Windows::Networking::NetworkOperators::NetworkOperatorTetheringAccessPointConfiguration^ arg0 = UnwrapNetworkOperatorTetheringAccessPointConfiguration(info[0]);
          
          op = wrapper->_instance->ConfigureAccessPointAsync(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 StartTetheringAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::NetworkOperators::NetworkOperatorTetheringOperationResult^>^ op;


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


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

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::NetworkOperators::NetworkOperatorTetheringOperationResult^>^ op;


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


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

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Networking::NetworkOperators::NetworkOperatorTetheringAccessPointConfiguration^ result;
          result = wrapper->_instance->GetCurrentAccessPointConfiguration();
          info.GetReturnValue().Set(WrapNetworkOperatorTetheringAccessPointConfiguration(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 GetTetheringClients(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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



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

      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Connectivity::ConnectionProfile^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Connectivity::NetworkAdapter^>(info[1]))
      {
        try
        {
          ::Windows::Networking::Connectivity::ConnectionProfile^ arg0 = dynamic_cast<::Windows::Networking::Connectivity::ConnectionProfile^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Networking::Connectivity::NetworkAdapter^ arg1 = dynamic_cast<::Windows::Networking::Connectivity::NetworkAdapter^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          ::Windows::Networking::NetworkOperators::NetworkOperatorTetheringManager^ result;
          result = ::Windows::Networking::NetworkOperators::NetworkOperatorTetheringManager::CreateFromConnectionProfile(arg0, arg1);
          info.GetReturnValue().Set(WrapNetworkOperatorTetheringManager(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Connectivity::ConnectionProfile^>(info[0]))
      {
        try
        {
          ::Windows::Networking::Connectivity::ConnectionProfile^ arg0 = dynamic_cast<::Windows::Networking::Connectivity::ConnectionProfile^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::Networking::NetworkOperators::NetworkOperatorTetheringManager^ result;
          result = ::Windows::Networking::NetworkOperators::NetworkOperatorTetheringManager::CreateFromConnectionProfile(arg0);
          info.GetReturnValue().Set(WrapNetworkOperatorTetheringManager(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 GetTetheringCapabilityFromConnectionProfile(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::Connectivity::ConnectionProfile^>(info[0]))
      {
        try
        {
          ::Windows::Networking::Connectivity::ConnectionProfile^ arg0 = dynamic_cast<::Windows::Networking::Connectivity::ConnectionProfile^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::Networking::NetworkOperators::TetheringCapability result;
          result = ::Windows::Networking::NetworkOperators::NetworkOperatorTetheringManager::GetTetheringCapabilityFromConnectionProfile(arg0);
          info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(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 GetTetheringCapability(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          ::Windows::Networking::NetworkOperators::TetheringCapability result;
          result = ::Windows::Networking::NetworkOperators::NetworkOperatorTetheringManager::GetTetheringCapability(arg0);
          info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(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 CreateFromNetworkAccountId(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          ::Windows::Networking::NetworkOperators::NetworkOperatorTetheringManager^ result;
          result = ::Windows::Networking::NetworkOperators::NetworkOperatorTetheringManager::CreateFromNetworkAccountId(arg0);
          info.GetReturnValue().Set(WrapNetworkOperatorTetheringManager(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 ClientCountGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

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

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

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

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


    private:
      ::Windows::Networking::NetworkOperators::NetworkOperatorTetheringManager^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapNetworkOperatorTetheringManager(::Windows::Networking::NetworkOperators::NetworkOperatorTetheringManager^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::NetworkOperatorTetheringManager^ UnwrapNetworkOperatorTetheringManager(Local<Value> value);
  };

  Persistent<FunctionTemplate> NetworkOperatorTetheringManager::s_constructorTemplate;

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

  ::Windows::Networking::NetworkOperators::NetworkOperatorTetheringManager^ UnwrapNetworkOperatorTetheringManager(Local<Value> value) {
     return NetworkOperatorTetheringManager::Unwrap<NetworkOperatorTetheringManager>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitNetworkOperatorTetheringManager(Local<Object> exports) {
    NetworkOperatorTetheringManager::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("hostNames").ToLocalChecked(), HostNamesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("macAddress").ToLocalChecked(), MacAddressGetter);

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



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

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

    private:

      NetworkOperatorTetheringClient(::Windows::Networking::NetworkOperators::NetworkOperatorTetheringClient^ 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::NetworkOperators::NetworkOperatorTetheringClient^ winRtInstance;


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

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

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





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

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::HostName^>^ result = wrapper->_instance->HostNames;
        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 MacAddressGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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


    private:
      ::Windows::Networking::NetworkOperators::NetworkOperatorTetheringClient^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapNetworkOperatorTetheringClient(::Windows::Networking::NetworkOperators::NetworkOperatorTetheringClient^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::NetworkOperatorTetheringClient^ UnwrapNetworkOperatorTetheringClient(Local<Value> value);
  };

  Persistent<FunctionTemplate> NetworkOperatorTetheringClient::s_constructorTemplate;

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

  ::Windows::Networking::NetworkOperators::NetworkOperatorTetheringClient^ UnwrapNetworkOperatorTetheringClient(Local<Value> value) {
     return NetworkOperatorTetheringClient::Unwrap<NetworkOperatorTetheringClient>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitNetworkOperatorTetheringClient(Local<Object> exports) {
    NetworkOperatorTetheringClient::Init(exports);
  }

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





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

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



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

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

    private:

      MobileBroadbandAccountEventArgs(::Windows::Networking::NetworkOperators::MobileBroadbandAccountEventArgs^ 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::NetworkOperators::MobileBroadbandAccountEventArgs^ winRtInstance;


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

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

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





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

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

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

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


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandAccountEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandAccountEventArgs(::Windows::Networking::NetworkOperators::MobileBroadbandAccountEventArgs^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandAccountEventArgs^ UnwrapMobileBroadbandAccountEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandAccountEventArgs::s_constructorTemplate;

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

  ::Windows::Networking::NetworkOperators::MobileBroadbandAccountEventArgs^ UnwrapMobileBroadbandAccountEventArgs(Local<Value> value) {
     return MobileBroadbandAccountEventArgs::Unwrap<MobileBroadbandAccountEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandAccountEventArgs(Local<Object> exports) {
    MobileBroadbandAccountEventArgs::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("hasDeviceInformationChanged").ToLocalChecked(), HasDeviceInformationChangedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("hasNetworkChanged").ToLocalChecked(), HasNetworkChangedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("networkAccountId").ToLocalChecked(), NetworkAccountIdGetter);

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



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

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

    private:

      MobileBroadbandAccountUpdatedEventArgs(::Windows::Networking::NetworkOperators::MobileBroadbandAccountUpdatedEventArgs^ 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::NetworkOperators::MobileBroadbandAccountUpdatedEventArgs^ winRtInstance;


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

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

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





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

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

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

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

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

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

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

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

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

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


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandAccountUpdatedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandAccountUpdatedEventArgs(::Windows::Networking::NetworkOperators::MobileBroadbandAccountUpdatedEventArgs^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandAccountUpdatedEventArgs^ UnwrapMobileBroadbandAccountUpdatedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandAccountUpdatedEventArgs::s_constructorTemplate;

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

  ::Windows::Networking::NetworkOperators::MobileBroadbandAccountUpdatedEventArgs^ UnwrapMobileBroadbandAccountUpdatedEventArgs(Local<Value> value) {
     return MobileBroadbandAccountUpdatedEventArgs::Unwrap<MobileBroadbandAccountUpdatedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandAccountUpdatedEventArgs(Local<Object> exports) {
    MobileBroadbandAccountUpdatedEventArgs::Init(exports);
  }

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


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


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

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

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



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

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

    private:

      MobileBroadbandAccountWatcher(::Windows::Networking::NetworkOperators::MobileBroadbandAccountWatcher^ 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::NetworkOperators::MobileBroadbandAccountWatcher^ winRtInstance;


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

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

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


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

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

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

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

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

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

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



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

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

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

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


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

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

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

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

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"accountAdded", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandAccountWatcher^>(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;
        }
        MobileBroadbandAccountWatcher *wrapper = MobileBroadbandAccountWatcher::Unwrap<MobileBroadbandAccountWatcher>(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->AccountAdded::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Networking::NetworkOperators::MobileBroadbandAccountWatcher^, ::Windows::Networking::NetworkOperators::MobileBroadbandAccountEventArgs^>(
            [callbackObjPtr](::Windows::Networking::NetworkOperators::MobileBroadbandAccountWatcher^ arg0, ::Windows::Networking::NetworkOperators::MobileBroadbandAccountEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapMobileBroadbandAccountWatcher(arg0);
                  wrappedArg1 = WrapMobileBroadbandAccountEventArgs(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"accountRemoved", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandAccountWatcher^>(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;
        }
        MobileBroadbandAccountWatcher *wrapper = MobileBroadbandAccountWatcher::Unwrap<MobileBroadbandAccountWatcher>(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->AccountRemoved::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Networking::NetworkOperators::MobileBroadbandAccountWatcher^, ::Windows::Networking::NetworkOperators::MobileBroadbandAccountEventArgs^>(
            [callbackObjPtr](::Windows::Networking::NetworkOperators::MobileBroadbandAccountWatcher^ arg0, ::Windows::Networking::NetworkOperators::MobileBroadbandAccountEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapMobileBroadbandAccountWatcher(arg0);
                  wrappedArg1 = WrapMobileBroadbandAccountEventArgs(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"accountUpdated", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandAccountWatcher^>(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;
        }
        MobileBroadbandAccountWatcher *wrapper = MobileBroadbandAccountWatcher::Unwrap<MobileBroadbandAccountWatcher>(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->AccountUpdated::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Networking::NetworkOperators::MobileBroadbandAccountWatcher^, ::Windows::Networking::NetworkOperators::MobileBroadbandAccountUpdatedEventArgs^>(
            [callbackObjPtr](::Windows::Networking::NetworkOperators::MobileBroadbandAccountWatcher^ arg0, ::Windows::Networking::NetworkOperators::MobileBroadbandAccountUpdatedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapMobileBroadbandAccountWatcher(arg0);
                  wrappedArg1 = WrapMobileBroadbandAccountUpdatedEventArgs(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"enumerationCompleted", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandAccountWatcher^>(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;
        }
        MobileBroadbandAccountWatcher *wrapper = MobileBroadbandAccountWatcher::Unwrap<MobileBroadbandAccountWatcher>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

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


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

                {
                  TryCatch tryCatch;


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


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

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

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"stopped", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandAccountWatcher^>(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;
        }
        MobileBroadbandAccountWatcher *wrapper = MobileBroadbandAccountWatcher::Unwrap<MobileBroadbandAccountWatcher>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

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


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

                {
                  TryCatch tryCatch;


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"accountAdded", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandAccountWatcher^>(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;
          }
          MobileBroadbandAccountWatcher *wrapper = MobileBroadbandAccountWatcher::Unwrap<MobileBroadbandAccountWatcher>(info.This());
          wrapper->_instance->AccountAdded::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"accountRemoved", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandAccountWatcher^>(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;
          }
          MobileBroadbandAccountWatcher *wrapper = MobileBroadbandAccountWatcher::Unwrap<MobileBroadbandAccountWatcher>(info.This());
          wrapper->_instance->AccountRemoved::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"accountUpdated", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandAccountWatcher^>(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;
          }
          MobileBroadbandAccountWatcher *wrapper = MobileBroadbandAccountWatcher::Unwrap<MobileBroadbandAccountWatcher>(info.This());
          wrapper->_instance->AccountUpdated::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"enumerationCompleted", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandAccountWatcher^>(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;
          }
          MobileBroadbandAccountWatcher *wrapper = MobileBroadbandAccountWatcher::Unwrap<MobileBroadbandAccountWatcher>(info.This());
          wrapper->_instance->EnumerationCompleted::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"stopped", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandAccountWatcher^>(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;
          }
          MobileBroadbandAccountWatcher *wrapper = MobileBroadbandAccountWatcher::Unwrap<MobileBroadbandAccountWatcher>(info.This());
          wrapper->_instance->Stopped::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

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

      friend v8::Local<v8::Value> WrapMobileBroadbandAccountWatcher(::Windows::Networking::NetworkOperators::MobileBroadbandAccountWatcher^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandAccountWatcher^ UnwrapMobileBroadbandAccountWatcher(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandAccountWatcher::s_constructorTemplate;

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

  ::Windows::Networking::NetworkOperators::MobileBroadbandAccountWatcher^ UnwrapMobileBroadbandAccountWatcher(Local<Value> value) {
     return MobileBroadbandAccountWatcher::Unwrap<MobileBroadbandAccountWatcher>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandAccountWatcher(Local<Object> exports) {
    MobileBroadbandAccountWatcher::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "getDeviceService", GetDeviceService);
          

          
            Nan::SetPrototypeMethod(localRef, "resetAsync", ResetAsync);
            Nan::SetPrototypeMethod(localRef, "getCurrentConfigurationAsync", GetCurrentConfigurationAsync);
            Nan::SetPrototypeMethod(localRef, "getIsPassthroughEnabledAsync", GetIsPassthroughEnabledAsync);
            Nan::SetPrototypeMethod(localRef, "setIsPassthroughEnabledAsync", SetIsPassthroughEnabledAsync);
            Nan::SetPrototypeMethod(localRef, "tryGetPcoAsync", TryGetPcoAsync);
          

          
          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>("currentAccount").ToLocalChecked(), CurrentAccountGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("currentNetwork").ToLocalChecked(), CurrentNetworkGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("deviceInformation").ToLocalChecked(), DeviceInformationGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("deviceServices").ToLocalChecked(), DeviceServicesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isResetSupported").ToLocalChecked(), IsResetSupportedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxDeviceServiceCommandSizeInBytes").ToLocalChecked(), MaxDeviceServiceCommandSizeInBytesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxDeviceServiceDataSizeInBytes").ToLocalChecked(), MaxDeviceServiceDataSizeInBytesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isInEmergencyCallMode").ToLocalChecked(), IsInEmergencyCallModeGetter);

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

        Nan::SetMethod(constructor, "getDeviceSelector", GetDeviceSelector);
        Nan::SetMethod(constructor, "fromId", FromId);
        Nan::SetMethod(constructor, "getDefault", GetDefault);


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

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

    private:

      MobileBroadbandModem(::Windows::Networking::NetworkOperators::MobileBroadbandModem^ 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::NetworkOperators::MobileBroadbandModem^ winRtInstance;


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

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

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

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

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

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

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


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

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::NetworkOperators::MobileBroadbandModemConfiguration^>^ op;


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


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

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

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

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


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

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::NetworkOperators::MobileBroadbandModemStatus>^ op;


      if (info.Length() == 2
        && info[0]->IsBoolean())
      {
        try
        {
          bool arg0 = Nan::To<bool>(info[0]).FromMaybe(false);
          
          op = wrapper->_instance->SetIsPassthroughEnabledAsync(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::NetworkOperators::MobileBroadbandModemStatus> 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 TryGetPcoAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::NetworkOperators::MobileBroadbandPco^>^ op;


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


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

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsGuid(info[0]))
      {
        try
        {
          ::Platform::Guid arg0 = NodeRT::Utils::GuidFromJs(info[0]);
          
          ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceService^ result;
          result = wrapper->_instance->GetDeviceService(arg0);
          info.GetReturnValue().Set(WrapMobileBroadbandDeviceService(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 GetDeviceSelector(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          Platform::String^ result;
          result = ::Windows::Networking::NetworkOperators::MobileBroadbandModem::GetDeviceSelector();
          info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
          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 FromId(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          ::Windows::Networking::NetworkOperators::MobileBroadbandModem^ result;
          result = ::Windows::Networking::NetworkOperators::MobileBroadbandModem::FromId(arg0);
          info.GetReturnValue().Set(WrapMobileBroadbandModem(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 GetDefault(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Networking::NetworkOperators::MobileBroadbandModem^ result;
          result = ::Windows::Networking::NetworkOperators::MobileBroadbandModem::GetDefault();
          info.GetReturnValue().Set(WrapMobileBroadbandModem(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 CurrentAccountGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"isInEmergencyCallModeChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandModem^>(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;
        }
        MobileBroadbandModem *wrapper = MobileBroadbandModem::Unwrap<MobileBroadbandModem>(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->IsInEmergencyCallModeChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Networking::NetworkOperators::MobileBroadbandModem^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Networking::NetworkOperators::MobileBroadbandModem^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


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


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

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

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

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

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

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

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

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

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

      if ((!NodeRT::Utils::CaseInsenstiveEquals(L"isInEmergencyCallModeChanged", 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"isInEmergencyCallModeChanged", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandModem^>(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;
          }
          MobileBroadbandModem *wrapper = MobileBroadbandModem::Unwrap<MobileBroadbandModem>(info.This());
          wrapper->_instance->IsInEmergencyCallModeChanged::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::NetworkOperators::MobileBroadbandModem^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandModem(::Windows::Networking::NetworkOperators::MobileBroadbandModem^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandModem^ UnwrapMobileBroadbandModem(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandModem::s_constructorTemplate;

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

  ::Windows::Networking::NetworkOperators::MobileBroadbandModem^ UnwrapMobileBroadbandModem(Local<Value> value) {
     return MobileBroadbandModem::Unwrap<MobileBroadbandModem>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandModem(Local<Object> exports) {
    MobileBroadbandModem::Init(exports);
  }

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

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


          
            Nan::SetPrototypeMethod(localRef, "getUiccAppsAsync", GetUiccAppsAsync);
          


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

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



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

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

    private:

      MobileBroadbandUicc(::Windows::Networking::NetworkOperators::MobileBroadbandUicc^ 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::NetworkOperators::MobileBroadbandUicc^ winRtInstance;


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

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

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

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

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppsResult^>^ op;


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


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

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

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

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


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandUicc^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandUicc(::Windows::Networking::NetworkOperators::MobileBroadbandUicc^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandUicc^ UnwrapMobileBroadbandUicc(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandUicc::s_constructorTemplate;

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

  ::Windows::Networking::NetworkOperators::MobileBroadbandUicc^ UnwrapMobileBroadbandUicc(Local<Value> value) {
     return MobileBroadbandUicc::Unwrap<MobileBroadbandUicc>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandUicc(Local<Object> exports) {
    MobileBroadbandUicc::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "startTransmissionStateMonitoring", StartTransmissionStateMonitoring);
            Nan::SetPrototypeMethod(localRef, "stopTransmissionStateMonitoring", StopTransmissionStateMonitoring);
          

          
            Nan::SetPrototypeMethod(localRef, "enableBackoffAsync", EnableBackoffAsync);
            Nan::SetPrototypeMethod(localRef, "disableBackoffAsync", DisableBackoffAsync);
            Nan::SetPrototypeMethod(localRef, "setConfigurationAsync", SetConfigurationAsync);
            Nan::SetPrototypeMethod(localRef, "revertSarToHardwareControlAsync", RevertSarToHardwareControlAsync);
            Nan::SetPrototypeMethod(localRef, "setTransmissionStateChangedHysteresisAsync", SetTransmissionStateChangedHysteresisAsync);
            Nan::SetPrototypeMethod(localRef, "getIsTransmittingAsync", GetIsTransmittingAsync);
          

          
          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>("antennas").ToLocalChecked(), AntennasGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("hysteresisTimerPeriod").ToLocalChecked(), HysteresisTimerPeriodGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isBackoffEnabled").ToLocalChecked(), IsBackoffEnabledGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isSarControlledByHardware").ToLocalChecked(), IsSarControlledByHardwareGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isWiFiHardwareIntegrated").ToLocalChecked(), IsWiFiHardwareIntegratedGetter);

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



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

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

    private:

      MobileBroadbandSarManager(::Windows::Networking::NetworkOperators::MobileBroadbandSarManager^ 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::NetworkOperators::MobileBroadbandSarManager^ winRtInstance;


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

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

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

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

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

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

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


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

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

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

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


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

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

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

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


      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Windows::Networking::NetworkOperators::MobileBroadbandAntennaSar^>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<::Windows::Networking::NetworkOperators::MobileBroadbandAntennaSar^>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Windows::Networking::NetworkOperators::MobileBroadbandAntennaSar^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Networking::NetworkOperators::MobileBroadbandAntennaSar^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandAntennaSar^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Networking::NetworkOperators::MobileBroadbandAntennaSar^ {
                   return UnwrapMobileBroadbandAntennaSar(value);
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Windows::Networking::NetworkOperators::MobileBroadbandAntennaSar^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          op = wrapper->_instance->SetConfigurationAsync(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 RevertSarToHardwareControlAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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


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

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

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

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


      if (info.Length() == 2
        && info[0]->IsNumber())
      {
        try
        {
          ::Windows::Foundation::TimeSpan arg0 = NodeRT::Utils::TimeSpanFromMilli(Nan::To<int64_t>(info[0]).FromMaybe(0));
          
          op = wrapper->_instance->SetTransmissionStateChangedHysteresisAsync(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 GetIsTransmittingAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"transmissionStateChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandSarManager^>(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;
        }
        MobileBroadbandSarManager *wrapper = MobileBroadbandSarManager::Unwrap<MobileBroadbandSarManager>(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->TransmissionStateChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Networking::NetworkOperators::MobileBroadbandSarManager^, ::Windows::Networking::NetworkOperators::MobileBroadbandTransmissionStateChangedEventArgs^>(
            [callbackObjPtr](::Windows::Networking::NetworkOperators::MobileBroadbandSarManager^ arg0, ::Windows::Networking::NetworkOperators::MobileBroadbandTransmissionStateChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapMobileBroadbandSarManager(arg0);
                  wrappedArg1 = WrapMobileBroadbandTransmissionStateChangedEventArgs(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"transmissionStateChanged", 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"transmissionStateChanged", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandSarManager^>(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;
          }
          MobileBroadbandSarManager *wrapper = MobileBroadbandSarManager::Unwrap<MobileBroadbandSarManager>(info.This());
          wrapper->_instance->TransmissionStateChanged::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::NetworkOperators::MobileBroadbandSarManager^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandSarManager(::Windows::Networking::NetworkOperators::MobileBroadbandSarManager^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandSarManager^ UnwrapMobileBroadbandSarManager(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandSarManager::s_constructorTemplate;

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

  ::Windows::Networking::NetworkOperators::MobileBroadbandSarManager^ UnwrapMobileBroadbandSarManager(Local<Value> value) {
     return MobileBroadbandSarManager::Unwrap<MobileBroadbandSarManager>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandSarManager(Local<Object> exports) {
    MobileBroadbandSarManager::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("homeProviderId").ToLocalChecked(), HomeProviderIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("homeProviderName").ToLocalChecked(), HomeProviderNameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("uicc").ToLocalChecked(), UiccGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("sarManager").ToLocalChecked(), SarManagerGetter);

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



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

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

    private:

      MobileBroadbandModemConfiguration(::Windows::Networking::NetworkOperators::MobileBroadbandModemConfiguration^ 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::NetworkOperators::MobileBroadbandModemConfiguration^ winRtInstance;


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

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

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





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

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

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

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

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

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

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

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

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

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

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

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

      try  {
        ::Windows::Networking::NetworkOperators::MobileBroadbandSarManager^ result = wrapper->_instance->SarManager;
        info.GetReturnValue().Set(WrapMobileBroadbandSarManager(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandModemConfiguration^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandModemConfiguration(::Windows::Networking::NetworkOperators::MobileBroadbandModemConfiguration^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandModemConfiguration^ UnwrapMobileBroadbandModemConfiguration(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandModemConfiguration::s_constructorTemplate;

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

  ::Windows::Networking::NetworkOperators::MobileBroadbandModemConfiguration^ UnwrapMobileBroadbandModemConfiguration(Local<Value> value) {
     return MobileBroadbandModemConfiguration::Unwrap<MobileBroadbandModemConfiguration>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandModemConfiguration(Local<Object> exports) {
    MobileBroadbandModemConfiguration::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("deviceServiceId").ToLocalChecked(), DeviceServiceIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isDataReadSupported").ToLocalChecked(), IsDataReadSupportedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isDataWriteSupported").ToLocalChecked(), IsDataWriteSupportedGetter);

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



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

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

    private:

      MobileBroadbandDeviceServiceInformation(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceInformation^ 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::NetworkOperators::MobileBroadbandDeviceServiceInformation^ winRtInstance;


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

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

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





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

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

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

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

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

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

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

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

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

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


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceInformation^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandDeviceServiceInformation(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceInformation^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceInformation^ UnwrapMobileBroadbandDeviceServiceInformation(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandDeviceServiceInformation::s_constructorTemplate;

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

  ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceInformation^ UnwrapMobileBroadbandDeviceServiceInformation(Local<Value> value) {
     return MobileBroadbandDeviceServiceInformation::Unwrap<MobileBroadbandDeviceServiceInformation>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandDeviceServiceInformation(Local<Object> exports) {
    MobileBroadbandDeviceServiceInformation::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "openDataSession", OpenDataSession);
            Nan::SetPrototypeMethod(localRef, "openCommandSession", OpenCommandSession);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("deviceServiceId").ToLocalChecked(), DeviceServiceIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("supportedCommands").ToLocalChecked(), SupportedCommandsGetter);

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



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

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

    private:

      MobileBroadbandDeviceService(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceService^ 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::NetworkOperators::MobileBroadbandDeviceService^ winRtInstance;


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

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

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


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

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceDataSession^ result;
          result = wrapper->_instance->OpenDataSession();
          info.GetReturnValue().Set(WrapMobileBroadbandDeviceServiceDataSession(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 OpenCommandSession(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandSession^ result;
          result = wrapper->_instance->OpenCommandSession();
          info.GetReturnValue().Set(WrapMobileBroadbandDeviceServiceCommandSession(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 DeviceServiceIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<unsigned int>^ result = wrapper->_instance->SupportedCommands;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned int>::CreateVectorViewWrapper(result, 
            [](unsigned int val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsUint32();
            },
            [](Local<Value> value) -> unsigned int {
              return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceService^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandDeviceService(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceService^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceService^ UnwrapMobileBroadbandDeviceService(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandDeviceService::s_constructorTemplate;

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

  ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceService^ UnwrapMobileBroadbandDeviceService(Local<Value> value) {
     return MobileBroadbandDeviceService::Unwrap<MobileBroadbandDeviceService>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandDeviceService(Local<Object> exports) {
    MobileBroadbandDeviceService::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("data").ToLocalChecked(), DataGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("deviceId").ToLocalChecked(), DeviceIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isComplete").ToLocalChecked(), IsCompleteGetter);

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



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

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

    private:

      MobileBroadbandPco(::Windows::Networking::NetworkOperators::MobileBroadbandPco^ 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::NetworkOperators::MobileBroadbandPco^ winRtInstance;


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

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

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





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

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

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

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

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

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

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

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

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

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


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandPco^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandPco(::Windows::Networking::NetworkOperators::MobileBroadbandPco^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandPco^ UnwrapMobileBroadbandPco(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandPco::s_constructorTemplate;

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

  ::Windows::Networking::NetworkOperators::MobileBroadbandPco^ UnwrapMobileBroadbandPco(Local<Value> value) {
     return MobileBroadbandPco::Unwrap<MobileBroadbandPco>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandPco(Local<Object> exports) {
    MobileBroadbandPco::Init(exports);
  }

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

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


          
            Nan::SetPrototypeMethod(localRef, "enableAsync", EnableAsync);
            Nan::SetPrototypeMethod(localRef, "disableAsync", DisableAsync);
            Nan::SetPrototypeMethod(localRef, "enterAsync", EnterAsync);
            Nan::SetPrototypeMethod(localRef, "changeAsync", ChangeAsync);
            Nan::SetPrototypeMethod(localRef, "unblockAsync", UnblockAsync);
          


          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("attemptsRemaining").ToLocalChecked(), AttemptsRemainingGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("enabled").ToLocalChecked(), EnabledGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("format").ToLocalChecked(), FormatGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("lockState").ToLocalChecked(), LockStateGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxLength").ToLocalChecked(), MaxLengthGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("minLength").ToLocalChecked(), MinLengthGetter);
            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>("MobileBroadbandPin").ToLocalChecked(), constructor);
      }

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

    private:

      MobileBroadbandPin(::Windows::Networking::NetworkOperators::MobileBroadbandPin^ 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::NetworkOperators::MobileBroadbandPin^ winRtInstance;


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

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

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

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

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::NetworkOperators::MobileBroadbandPinOperationResult^>^ 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->EnableAsync(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::NetworkOperators::MobileBroadbandPinOperationResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::NetworkOperators::MobileBroadbandPinOperationResult^>^ 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->DisableAsync(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::NetworkOperators::MobileBroadbandPinOperationResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::NetworkOperators::MobileBroadbandPinOperationResult^>^ 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->EnterAsync(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::NetworkOperators::MobileBroadbandPinOperationResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::NetworkOperators::MobileBroadbandPinOperationResult^>^ op;


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


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

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::NetworkOperators::MobileBroadbandPinOperationResult^>^ op;


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try  {
        ::Windows::Networking::NetworkOperators::MobileBroadbandPinType 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::NetworkOperators::MobileBroadbandPin^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandPin(::Windows::Networking::NetworkOperators::MobileBroadbandPin^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandPin^ UnwrapMobileBroadbandPin(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandPin::s_constructorTemplate;

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

  ::Windows::Networking::NetworkOperators::MobileBroadbandPin^ UnwrapMobileBroadbandPin(Local<Value> value) {
     return MobileBroadbandPin::Unwrap<MobileBroadbandPin>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandPin(Local<Object> exports) {
    MobileBroadbandPin::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("attemptsRemaining").ToLocalChecked(), AttemptsRemainingGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isSuccessful").ToLocalChecked(), IsSuccessfulGetter);

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



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

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

    private:

      MobileBroadbandPinOperationResult(::Windows::Networking::NetworkOperators::MobileBroadbandPinOperationResult^ 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::NetworkOperators::MobileBroadbandPinOperationResult^ winRtInstance;


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

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

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





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

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

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

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

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

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

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


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandPinOperationResult^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandPinOperationResult(::Windows::Networking::NetworkOperators::MobileBroadbandPinOperationResult^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandPinOperationResult^ UnwrapMobileBroadbandPinOperationResult(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandPinOperationResult::s_constructorTemplate;

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

  ::Windows::Networking::NetworkOperators::MobileBroadbandPinOperationResult^ UnwrapMobileBroadbandPinOperationResult(Local<Value> value) {
     return MobileBroadbandPinOperationResult::Unwrap<MobileBroadbandPinOperationResult>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandPinOperationResult(Local<Object> exports) {
    MobileBroadbandPinOperationResult::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "closeSession", CloseSession);
          

          
            Nan::SetPrototypeMethod(localRef, "writeDataAsync", WriteDataAsync);
          

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


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



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

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

    private:

      MobileBroadbandDeviceServiceDataSession(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceDataSession^ 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::NetworkOperators::MobileBroadbandDeviceServiceDataSession^ winRtInstance;


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

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

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

    static void WriteDataAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceDataSession^>(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;
      }

      MobileBroadbandDeviceServiceDataSession *wrapper = MobileBroadbandDeviceServiceDataSession::Unwrap<MobileBroadbandDeviceServiceDataSession>(info.This());

      ::Windows::Foundation::IAsyncAction^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IBuffer^>(info[0]))
      {
        try
        {
          ::Windows::Storage::Streams::IBuffer^ arg0 = dynamic_cast<::Windows::Storage::Streams::IBuffer^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          op = wrapper->_instance->WriteDataAsync(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 CloseSession(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceDataSession^>(info.This())) {
        return;
      }

      MobileBroadbandDeviceServiceDataSession *wrapper = MobileBroadbandDeviceServiceDataSession::Unwrap<MobileBroadbandDeviceServiceDataSession>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->CloseSession();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





    static void AddListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"dataReceived", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceDataSession^>(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;
        }
        MobileBroadbandDeviceServiceDataSession *wrapper = MobileBroadbandDeviceServiceDataSession::Unwrap<MobileBroadbandDeviceServiceDataSession>(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->DataReceived::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceDataSession^, ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceDataReceivedEventArgs^>(
            [callbackObjPtr](::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceDataSession^ arg0, ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceDataReceivedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapMobileBroadbandDeviceServiceDataSession(arg0);
                  wrappedArg1 = WrapMobileBroadbandDeviceServiceDataReceivedEventArgs(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"dataReceived", 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"dataReceived", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceDataSession^>(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;
          }
          MobileBroadbandDeviceServiceDataSession *wrapper = MobileBroadbandDeviceServiceDataSession::Unwrap<MobileBroadbandDeviceServiceDataSession>(info.This());
          wrapper->_instance->DataReceived::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::NetworkOperators::MobileBroadbandDeviceServiceDataSession^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandDeviceServiceDataSession(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceDataSession^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceDataSession^ UnwrapMobileBroadbandDeviceServiceDataSession(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandDeviceServiceDataSession::s_constructorTemplate;

  v8::Local<v8::Value> WrapMobileBroadbandDeviceServiceDataSession(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceDataSession^ 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>(MobileBroadbandDeviceServiceDataSession::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceDataSession^ UnwrapMobileBroadbandDeviceServiceDataSession(Local<Value> value) {
     return MobileBroadbandDeviceServiceDataSession::Unwrap<MobileBroadbandDeviceServiceDataSession>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandDeviceServiceDataSession(Local<Object> exports) {
    MobileBroadbandDeviceServiceDataSession::Init(exports);
  }

  class MobileBroadbandDeviceServiceCommandSession : 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>("MobileBroadbandDeviceServiceCommandSession").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);

        Local<Function> func;
        Local<FunctionTemplate> funcTemplate;

          
            Nan::SetPrototypeMethod(localRef, "closeSession", CloseSession);
          

          
            Nan::SetPrototypeMethod(localRef, "sendQueryCommandAsync", SendQueryCommandAsync);
            Nan::SetPrototypeMethod(localRef, "sendSetCommandAsync", SendSetCommandAsync);
          



        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("MobileBroadbandDeviceServiceCommandSession").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      MobileBroadbandDeviceServiceCommandSession(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandSession^ 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::NetworkOperators::MobileBroadbandDeviceServiceCommandSession^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandSession^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandSession^) 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());

      MobileBroadbandDeviceServiceCommandSession *wrapperInstance = new MobileBroadbandDeviceServiceCommandSession(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::NetworkOperators::MobileBroadbandDeviceServiceCommandSession^>(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::NetworkOperators::MobileBroadbandDeviceServiceCommandSession^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandSession^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapMobileBroadbandDeviceServiceCommandSession(winRtInstance));
    }

    static void SendQueryCommandAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandSession^>(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;
      }

      MobileBroadbandDeviceServiceCommandSession *wrapper = MobileBroadbandDeviceServiceCommandSession::Unwrap<MobileBroadbandDeviceServiceCommandSession>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandResult^>^ op;


      if (info.Length() == 3
        && info[0]->IsUint32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IBuffer^>(info[1]))
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          ::Windows::Storage::Streams::IBuffer^ arg1 = dynamic_cast<::Windows::Storage::Streams::IBuffer^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          op = wrapper->_instance->SendQueryCommandAsync(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::NetworkOperators::MobileBroadbandDeviceServiceCommandResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapMobileBroadbandDeviceServiceCommandResult(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 SendSetCommandAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandSession^>(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;
      }

      MobileBroadbandDeviceServiceCommandSession *wrapper = MobileBroadbandDeviceServiceCommandSession::Unwrap<MobileBroadbandDeviceServiceCommandSession>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandResult^>^ op;


      if (info.Length() == 3
        && info[0]->IsUint32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IBuffer^>(info[1]))
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          ::Windows::Storage::Streams::IBuffer^ arg1 = dynamic_cast<::Windows::Storage::Streams::IBuffer^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          op = wrapper->_instance->SendSetCommandAsync(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::NetworkOperators::MobileBroadbandDeviceServiceCommandResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapMobileBroadbandDeviceServiceCommandResult(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 CloseSession(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandSession^>(info.This())) {
        return;
      }

      MobileBroadbandDeviceServiceCommandSession *wrapper = MobileBroadbandDeviceServiceCommandSession::Unwrap<MobileBroadbandDeviceServiceCommandSession>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->CloseSession();
          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::NetworkOperators::MobileBroadbandDeviceServiceCommandSession^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandDeviceServiceCommandSession(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandSession^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandSession^ UnwrapMobileBroadbandDeviceServiceCommandSession(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandDeviceServiceCommandSession::s_constructorTemplate;

  v8::Local<v8::Value> WrapMobileBroadbandDeviceServiceCommandSession(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandSession^ 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>(MobileBroadbandDeviceServiceCommandSession::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandSession^ UnwrapMobileBroadbandDeviceServiceCommandSession(Local<Value> value) {
     return MobileBroadbandDeviceServiceCommandSession::Unwrap<MobileBroadbandDeviceServiceCommandSession>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandDeviceServiceCommandSession(Local<Object> exports) {
    MobileBroadbandDeviceServiceCommandSession::Init(exports);
  }

  class MobileBroadbandDeviceServiceDataReceivedEventArgs : 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>("MobileBroadbandDeviceServiceDataReceivedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("receivedData").ToLocalChecked(), ReceivedDataGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("MobileBroadbandDeviceServiceDataReceivedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      MobileBroadbandDeviceServiceDataReceivedEventArgs(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceDataReceivedEventArgs^ 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::NetworkOperators::MobileBroadbandDeviceServiceDataReceivedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceDataReceivedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceDataReceivedEventArgs^) 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());

      MobileBroadbandDeviceServiceDataReceivedEventArgs *wrapperInstance = new MobileBroadbandDeviceServiceDataReceivedEventArgs(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::NetworkOperators::MobileBroadbandDeviceServiceDataReceivedEventArgs^>(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::NetworkOperators::MobileBroadbandDeviceServiceDataReceivedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceDataReceivedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapMobileBroadbandDeviceServiceDataReceivedEventArgs(winRtInstance));
    }





    static void ReceivedDataGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceDataReceivedEventArgs^>(info.This())) {
        return;
      }

      MobileBroadbandDeviceServiceDataReceivedEventArgs *wrapper = MobileBroadbandDeviceServiceDataReceivedEventArgs::Unwrap<MobileBroadbandDeviceServiceDataReceivedEventArgs>(info.This());

      try  {
        ::Windows::Storage::Streams::IBuffer^ result = wrapper->_instance->ReceivedData;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Storage.Streams", "IBuffer", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceDataReceivedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandDeviceServiceDataReceivedEventArgs(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceDataReceivedEventArgs^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceDataReceivedEventArgs^ UnwrapMobileBroadbandDeviceServiceDataReceivedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandDeviceServiceDataReceivedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapMobileBroadbandDeviceServiceDataReceivedEventArgs(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceDataReceivedEventArgs^ 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>(MobileBroadbandDeviceServiceDataReceivedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceDataReceivedEventArgs^ UnwrapMobileBroadbandDeviceServiceDataReceivedEventArgs(Local<Value> value) {
     return MobileBroadbandDeviceServiceDataReceivedEventArgs::Unwrap<MobileBroadbandDeviceServiceDataReceivedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandDeviceServiceDataReceivedEventArgs(Local<Object> exports) {
    MobileBroadbandDeviceServiceDataReceivedEventArgs::Init(exports);
  }

  class MobileBroadbandDeviceServiceCommandResult : 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>("MobileBroadbandDeviceServiceCommandResult").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("responseData").ToLocalChecked(), ResponseDataGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("statusCode").ToLocalChecked(), StatusCodeGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("MobileBroadbandDeviceServiceCommandResult").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      MobileBroadbandDeviceServiceCommandResult(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandResult^ 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::NetworkOperators::MobileBroadbandDeviceServiceCommandResult^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandResult^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandResult^) 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());

      MobileBroadbandDeviceServiceCommandResult *wrapperInstance = new MobileBroadbandDeviceServiceCommandResult(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::NetworkOperators::MobileBroadbandDeviceServiceCommandResult^>(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::NetworkOperators::MobileBroadbandDeviceServiceCommandResult^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandResult^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapMobileBroadbandDeviceServiceCommandResult(winRtInstance));
    }





    static void ResponseDataGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandResult^>(info.This())) {
        return;
      }

      MobileBroadbandDeviceServiceCommandResult *wrapper = MobileBroadbandDeviceServiceCommandResult::Unwrap<MobileBroadbandDeviceServiceCommandResult>(info.This());

      try  {
        ::Windows::Storage::Streams::IBuffer^ result = wrapper->_instance->ResponseData;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Storage.Streams", "IBuffer", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void StatusCodeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandResult^>(info.This())) {
        return;
      }

      MobileBroadbandDeviceServiceCommandResult *wrapper = MobileBroadbandDeviceServiceCommandResult::Unwrap<MobileBroadbandDeviceServiceCommandResult>(info.This());

      try  {
        unsigned int result = wrapper->_instance->StatusCode;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandResult^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandDeviceServiceCommandResult(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandResult^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandResult^ UnwrapMobileBroadbandDeviceServiceCommandResult(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandDeviceServiceCommandResult::s_constructorTemplate;

  v8::Local<v8::Value> WrapMobileBroadbandDeviceServiceCommandResult(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandResult^ 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>(MobileBroadbandDeviceServiceCommandResult::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceCommandResult^ UnwrapMobileBroadbandDeviceServiceCommandResult(Local<Value> value) {
     return MobileBroadbandDeviceServiceCommandResult::Unwrap<MobileBroadbandDeviceServiceCommandResult>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandDeviceServiceCommandResult(Local<Object> exports) {
    MobileBroadbandDeviceServiceCommandResult::Init(exports);
  }

  class MobileBroadbandUiccAppsResult : 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>("MobileBroadbandUiccAppsResult").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("status").ToLocalChecked(), StatusGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("uiccApps").ToLocalChecked(), UiccAppsGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("MobileBroadbandUiccAppsResult").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      MobileBroadbandUiccAppsResult(::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppsResult^ 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::NetworkOperators::MobileBroadbandUiccAppsResult^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppsResult^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppsResult^) 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());

      MobileBroadbandUiccAppsResult *wrapperInstance = new MobileBroadbandUiccAppsResult(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::NetworkOperators::MobileBroadbandUiccAppsResult^>(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::NetworkOperators::MobileBroadbandUiccAppsResult^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppsResult^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapMobileBroadbandUiccAppsResult(winRtInstance));
    }





    static void StatusGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppsResult^>(info.This())) {
        return;
      }

      MobileBroadbandUiccAppsResult *wrapper = MobileBroadbandUiccAppsResult::Unwrap<MobileBroadbandUiccAppsResult>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppOperationStatus 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 UiccAppsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppsResult^>(info.This())) {
        return;
      }

      MobileBroadbandUiccAppsResult *wrapper = MobileBroadbandUiccAppsResult::Unwrap<MobileBroadbandUiccAppsResult>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::NetworkOperators::MobileBroadbandUiccApp^>^ result = wrapper->_instance->UiccApps;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Networking::NetworkOperators::MobileBroadbandUiccApp^>::CreateVectorViewWrapper(result, 
            [](::Windows::Networking::NetworkOperators::MobileBroadbandUiccApp^ val) -> Local<Value> {
              return WrapMobileBroadbandUiccApp(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandUiccApp^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::NetworkOperators::MobileBroadbandUiccApp^ {
              return UnwrapMobileBroadbandUiccApp(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppsResult^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandUiccAppsResult(::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppsResult^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppsResult^ UnwrapMobileBroadbandUiccAppsResult(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandUiccAppsResult::s_constructorTemplate;

  v8::Local<v8::Value> WrapMobileBroadbandUiccAppsResult(::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppsResult^ 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>(MobileBroadbandUiccAppsResult::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppsResult^ UnwrapMobileBroadbandUiccAppsResult(Local<Value> value) {
     return MobileBroadbandUiccAppsResult::Unwrap<MobileBroadbandUiccAppsResult>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandUiccAppsResult(Local<Object> exports) {
    MobileBroadbandUiccAppsResult::Init(exports);
  }

  class MobileBroadbandUiccAppRecordDetailsResult : 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>("MobileBroadbandUiccAppRecordDetailsResult").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("readAccessCondition").ToLocalChecked(), ReadAccessConditionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("recordCount").ToLocalChecked(), RecordCountGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("recordSize").ToLocalChecked(), RecordSizeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("status").ToLocalChecked(), StatusGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("writeAccessCondition").ToLocalChecked(), WriteAccessConditionGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("MobileBroadbandUiccAppRecordDetailsResult").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      MobileBroadbandUiccAppRecordDetailsResult(::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppRecordDetailsResult^ 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::NetworkOperators::MobileBroadbandUiccAppRecordDetailsResult^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppRecordDetailsResult^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppRecordDetailsResult^) 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());

      MobileBroadbandUiccAppRecordDetailsResult *wrapperInstance = new MobileBroadbandUiccAppRecordDetailsResult(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::NetworkOperators::MobileBroadbandUiccAppRecordDetailsResult^>(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::NetworkOperators::MobileBroadbandUiccAppRecordDetailsResult^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppRecordDetailsResult^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapMobileBroadbandUiccAppRecordDetailsResult(winRtInstance));
    }





    static void KindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppRecordDetailsResult^>(info.This())) {
        return;
      }

      MobileBroadbandUiccAppRecordDetailsResult *wrapper = MobileBroadbandUiccAppRecordDetailsResult::Unwrap<MobileBroadbandUiccAppRecordDetailsResult>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::UiccAppRecordKind result = wrapper->_instance->Kind;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ReadAccessConditionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppRecordDetailsResult^>(info.This())) {
        return;
      }

      MobileBroadbandUiccAppRecordDetailsResult *wrapper = MobileBroadbandUiccAppRecordDetailsResult::Unwrap<MobileBroadbandUiccAppRecordDetailsResult>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::UiccAccessCondition result = wrapper->_instance->ReadAccessCondition;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RecordCountGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppRecordDetailsResult^>(info.This())) {
        return;
      }

      MobileBroadbandUiccAppRecordDetailsResult *wrapper = MobileBroadbandUiccAppRecordDetailsResult::Unwrap<MobileBroadbandUiccAppRecordDetailsResult>(info.This());

      try  {
        int result = wrapper->_instance->RecordCount;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RecordSizeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppRecordDetailsResult^>(info.This())) {
        return;
      }

      MobileBroadbandUiccAppRecordDetailsResult *wrapper = MobileBroadbandUiccAppRecordDetailsResult::Unwrap<MobileBroadbandUiccAppRecordDetailsResult>(info.This());

      try  {
        int result = wrapper->_instance->RecordSize;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void StatusGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppRecordDetailsResult^>(info.This())) {
        return;
      }

      MobileBroadbandUiccAppRecordDetailsResult *wrapper = MobileBroadbandUiccAppRecordDetailsResult::Unwrap<MobileBroadbandUiccAppRecordDetailsResult>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppOperationStatus 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 WriteAccessConditionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppRecordDetailsResult^>(info.This())) {
        return;
      }

      MobileBroadbandUiccAppRecordDetailsResult *wrapper = MobileBroadbandUiccAppRecordDetailsResult::Unwrap<MobileBroadbandUiccAppRecordDetailsResult>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::UiccAccessCondition result = wrapper->_instance->WriteAccessCondition;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppRecordDetailsResult^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandUiccAppRecordDetailsResult(::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppRecordDetailsResult^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppRecordDetailsResult^ UnwrapMobileBroadbandUiccAppRecordDetailsResult(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandUiccAppRecordDetailsResult::s_constructorTemplate;

  v8::Local<v8::Value> WrapMobileBroadbandUiccAppRecordDetailsResult(::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppRecordDetailsResult^ 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>(MobileBroadbandUiccAppRecordDetailsResult::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppRecordDetailsResult^ UnwrapMobileBroadbandUiccAppRecordDetailsResult(Local<Value> value) {
     return MobileBroadbandUiccAppRecordDetailsResult::Unwrap<MobileBroadbandUiccAppRecordDetailsResult>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandUiccAppRecordDetailsResult(Local<Object> exports) {
    MobileBroadbandUiccAppRecordDetailsResult::Init(exports);
  }

  class MobileBroadbandUiccAppReadRecordResult : 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>("MobileBroadbandUiccAppReadRecordResult").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("data").ToLocalChecked(), DataGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("status").ToLocalChecked(), StatusGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("MobileBroadbandUiccAppReadRecordResult").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      MobileBroadbandUiccAppReadRecordResult(::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppReadRecordResult^ 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::NetworkOperators::MobileBroadbandUiccAppReadRecordResult^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppReadRecordResult^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppReadRecordResult^) 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());

      MobileBroadbandUiccAppReadRecordResult *wrapperInstance = new MobileBroadbandUiccAppReadRecordResult(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::NetworkOperators::MobileBroadbandUiccAppReadRecordResult^>(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::NetworkOperators::MobileBroadbandUiccAppReadRecordResult^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppReadRecordResult^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapMobileBroadbandUiccAppReadRecordResult(winRtInstance));
    }





    static void DataGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppReadRecordResult^>(info.This())) {
        return;
      }

      MobileBroadbandUiccAppReadRecordResult *wrapper = MobileBroadbandUiccAppReadRecordResult::Unwrap<MobileBroadbandUiccAppReadRecordResult>(info.This());

      try  {
        ::Windows::Storage::Streams::IBuffer^ result = wrapper->_instance->Data;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Storage.Streams", "IBuffer", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void StatusGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppReadRecordResult^>(info.This())) {
        return;
      }

      MobileBroadbandUiccAppReadRecordResult *wrapper = MobileBroadbandUiccAppReadRecordResult::Unwrap<MobileBroadbandUiccAppReadRecordResult>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppOperationStatus result = wrapper->_instance->Status;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppReadRecordResult^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandUiccAppReadRecordResult(::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppReadRecordResult^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppReadRecordResult^ UnwrapMobileBroadbandUiccAppReadRecordResult(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandUiccAppReadRecordResult::s_constructorTemplate;

  v8::Local<v8::Value> WrapMobileBroadbandUiccAppReadRecordResult(::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppReadRecordResult^ 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>(MobileBroadbandUiccAppReadRecordResult::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::MobileBroadbandUiccAppReadRecordResult^ UnwrapMobileBroadbandUiccAppReadRecordResult(Local<Value> value) {
     return MobileBroadbandUiccAppReadRecordResult::Unwrap<MobileBroadbandUiccAppReadRecordResult>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandUiccAppReadRecordResult(Local<Object> exports) {
    MobileBroadbandUiccAppReadRecordResult::Init(exports);
  }

  class MobileBroadbandNetworkRegistrationStateChange : 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>("MobileBroadbandNetworkRegistrationStateChange").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("deviceId").ToLocalChecked(), DeviceIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("network").ToLocalChecked(), NetworkGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("MobileBroadbandNetworkRegistrationStateChange").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      MobileBroadbandNetworkRegistrationStateChange(::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChange^ 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::NetworkOperators::MobileBroadbandNetworkRegistrationStateChange^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChange^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChange^) 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());

      MobileBroadbandNetworkRegistrationStateChange *wrapperInstance = new MobileBroadbandNetworkRegistrationStateChange(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::NetworkOperators::MobileBroadbandNetworkRegistrationStateChange^>(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::NetworkOperators::MobileBroadbandNetworkRegistrationStateChange^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChange^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapMobileBroadbandNetworkRegistrationStateChange(winRtInstance));
    }





    static void DeviceIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChange^>(info.This())) {
        return;
      }

      MobileBroadbandNetworkRegistrationStateChange *wrapper = MobileBroadbandNetworkRegistrationStateChange::Unwrap<MobileBroadbandNetworkRegistrationStateChange>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->DeviceId;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void NetworkGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChange^>(info.This())) {
        return;
      }

      MobileBroadbandNetworkRegistrationStateChange *wrapper = MobileBroadbandNetworkRegistrationStateChange::Unwrap<MobileBroadbandNetworkRegistrationStateChange>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::MobileBroadbandNetwork^ result = wrapper->_instance->Network;
        info.GetReturnValue().Set(WrapMobileBroadbandNetwork(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChange^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandNetworkRegistrationStateChange(::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChange^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChange^ UnwrapMobileBroadbandNetworkRegistrationStateChange(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandNetworkRegistrationStateChange::s_constructorTemplate;

  v8::Local<v8::Value> WrapMobileBroadbandNetworkRegistrationStateChange(::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChange^ 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>(MobileBroadbandNetworkRegistrationStateChange::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChange^ UnwrapMobileBroadbandNetworkRegistrationStateChange(Local<Value> value) {
     return MobileBroadbandNetworkRegistrationStateChange::Unwrap<MobileBroadbandNetworkRegistrationStateChange>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandNetworkRegistrationStateChange(Local<Object> exports) {
    MobileBroadbandNetworkRegistrationStateChange::Init(exports);
  }

  class MobileBroadbandNetworkRegistrationStateChangeTriggerDetails : 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>("MobileBroadbandNetworkRegistrationStateChangeTriggerDetails").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("networkRegistrationStateChanges").ToLocalChecked(), NetworkRegistrationStateChangesGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("MobileBroadbandNetworkRegistrationStateChangeTriggerDetails").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      MobileBroadbandNetworkRegistrationStateChangeTriggerDetails(::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChangeTriggerDetails^ 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::NetworkOperators::MobileBroadbandNetworkRegistrationStateChangeTriggerDetails^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChangeTriggerDetails^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChangeTriggerDetails^) 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());

      MobileBroadbandNetworkRegistrationStateChangeTriggerDetails *wrapperInstance = new MobileBroadbandNetworkRegistrationStateChangeTriggerDetails(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::NetworkOperators::MobileBroadbandNetworkRegistrationStateChangeTriggerDetails^>(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::NetworkOperators::MobileBroadbandNetworkRegistrationStateChangeTriggerDetails^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChangeTriggerDetails^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapMobileBroadbandNetworkRegistrationStateChangeTriggerDetails(winRtInstance));
    }





    static void NetworkRegistrationStateChangesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChangeTriggerDetails^>(info.This())) {
        return;
      }

      MobileBroadbandNetworkRegistrationStateChangeTriggerDetails *wrapper = MobileBroadbandNetworkRegistrationStateChangeTriggerDetails::Unwrap<MobileBroadbandNetworkRegistrationStateChangeTriggerDetails>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChange^>^ result = wrapper->_instance->NetworkRegistrationStateChanges;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChange^>::CreateVectorViewWrapper(result, 
            [](::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChange^ val) -> Local<Value> {
              return WrapMobileBroadbandNetworkRegistrationStateChange(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChange^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChange^ {
              return UnwrapMobileBroadbandNetworkRegistrationStateChange(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChangeTriggerDetails^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandNetworkRegistrationStateChangeTriggerDetails(::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChangeTriggerDetails^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChangeTriggerDetails^ UnwrapMobileBroadbandNetworkRegistrationStateChangeTriggerDetails(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandNetworkRegistrationStateChangeTriggerDetails::s_constructorTemplate;

  v8::Local<v8::Value> WrapMobileBroadbandNetworkRegistrationStateChangeTriggerDetails(::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChangeTriggerDetails^ 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>(MobileBroadbandNetworkRegistrationStateChangeTriggerDetails::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::MobileBroadbandNetworkRegistrationStateChangeTriggerDetails^ UnwrapMobileBroadbandNetworkRegistrationStateChangeTriggerDetails(Local<Value> value) {
     return MobileBroadbandNetworkRegistrationStateChangeTriggerDetails::Unwrap<MobileBroadbandNetworkRegistrationStateChangeTriggerDetails>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandNetworkRegistrationStateChangeTriggerDetails(Local<Object> exports) {
    MobileBroadbandNetworkRegistrationStateChangeTriggerDetails::Init(exports);
  }

  class MobileBroadbandRadioStateChange : 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>("MobileBroadbandRadioStateChange").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("deviceId").ToLocalChecked(), DeviceIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("radioState").ToLocalChecked(), RadioStateGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("MobileBroadbandRadioStateChange").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      MobileBroadbandRadioStateChange(::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChange^ 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::NetworkOperators::MobileBroadbandRadioStateChange^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChange^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChange^) 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());

      MobileBroadbandRadioStateChange *wrapperInstance = new MobileBroadbandRadioStateChange(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::NetworkOperators::MobileBroadbandRadioStateChange^>(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::NetworkOperators::MobileBroadbandRadioStateChange^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChange^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapMobileBroadbandRadioStateChange(winRtInstance));
    }





    static void DeviceIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChange^>(info.This())) {
        return;
      }

      MobileBroadbandRadioStateChange *wrapper = MobileBroadbandRadioStateChange::Unwrap<MobileBroadbandRadioStateChange>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->DeviceId;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RadioStateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChange^>(info.This())) {
        return;
      }

      MobileBroadbandRadioStateChange *wrapper = MobileBroadbandRadioStateChange::Unwrap<MobileBroadbandRadioStateChange>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::MobileBroadbandRadioState result = wrapper->_instance->RadioState;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChange^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandRadioStateChange(::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChange^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChange^ UnwrapMobileBroadbandRadioStateChange(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandRadioStateChange::s_constructorTemplate;

  v8::Local<v8::Value> WrapMobileBroadbandRadioStateChange(::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChange^ 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>(MobileBroadbandRadioStateChange::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChange^ UnwrapMobileBroadbandRadioStateChange(Local<Value> value) {
     return MobileBroadbandRadioStateChange::Unwrap<MobileBroadbandRadioStateChange>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandRadioStateChange(Local<Object> exports) {
    MobileBroadbandRadioStateChange::Init(exports);
  }

  class MobileBroadbandRadioStateChangeTriggerDetails : 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>("MobileBroadbandRadioStateChangeTriggerDetails").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("radioStateChanges").ToLocalChecked(), RadioStateChangesGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("MobileBroadbandRadioStateChangeTriggerDetails").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      MobileBroadbandRadioStateChangeTriggerDetails(::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChangeTriggerDetails^ 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::NetworkOperators::MobileBroadbandRadioStateChangeTriggerDetails^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChangeTriggerDetails^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChangeTriggerDetails^) 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());

      MobileBroadbandRadioStateChangeTriggerDetails *wrapperInstance = new MobileBroadbandRadioStateChangeTriggerDetails(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::NetworkOperators::MobileBroadbandRadioStateChangeTriggerDetails^>(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::NetworkOperators::MobileBroadbandRadioStateChangeTriggerDetails^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChangeTriggerDetails^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapMobileBroadbandRadioStateChangeTriggerDetails(winRtInstance));
    }





    static void RadioStateChangesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChangeTriggerDetails^>(info.This())) {
        return;
      }

      MobileBroadbandRadioStateChangeTriggerDetails *wrapper = MobileBroadbandRadioStateChangeTriggerDetails::Unwrap<MobileBroadbandRadioStateChangeTriggerDetails>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChange^>^ result = wrapper->_instance->RadioStateChanges;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChange^>::CreateVectorViewWrapper(result, 
            [](::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChange^ val) -> Local<Value> {
              return WrapMobileBroadbandRadioStateChange(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChange^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChange^ {
              return UnwrapMobileBroadbandRadioStateChange(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChangeTriggerDetails^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandRadioStateChangeTriggerDetails(::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChangeTriggerDetails^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChangeTriggerDetails^ UnwrapMobileBroadbandRadioStateChangeTriggerDetails(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandRadioStateChangeTriggerDetails::s_constructorTemplate;

  v8::Local<v8::Value> WrapMobileBroadbandRadioStateChangeTriggerDetails(::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChangeTriggerDetails^ 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>(MobileBroadbandRadioStateChangeTriggerDetails::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::MobileBroadbandRadioStateChangeTriggerDetails^ UnwrapMobileBroadbandRadioStateChangeTriggerDetails(Local<Value> value) {
     return MobileBroadbandRadioStateChangeTriggerDetails::Unwrap<MobileBroadbandRadioStateChangeTriggerDetails>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandRadioStateChangeTriggerDetails(Local<Object> exports) {
    MobileBroadbandRadioStateChangeTriggerDetails::Init(exports);
  }

  class MobileBroadbandPinLockStateChange : 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>("MobileBroadbandPinLockStateChange").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("deviceId").ToLocalChecked(), DeviceIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pinLockState").ToLocalChecked(), PinLockStateGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pinType").ToLocalChecked(), PinTypeGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("MobileBroadbandPinLockStateChange").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      MobileBroadbandPinLockStateChange(::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChange^ 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::NetworkOperators::MobileBroadbandPinLockStateChange^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChange^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChange^) 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());

      MobileBroadbandPinLockStateChange *wrapperInstance = new MobileBroadbandPinLockStateChange(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::NetworkOperators::MobileBroadbandPinLockStateChange^>(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::NetworkOperators::MobileBroadbandPinLockStateChange^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChange^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapMobileBroadbandPinLockStateChange(winRtInstance));
    }





    static void DeviceIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChange^>(info.This())) {
        return;
      }

      MobileBroadbandPinLockStateChange *wrapper = MobileBroadbandPinLockStateChange::Unwrap<MobileBroadbandPinLockStateChange>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->DeviceId;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PinLockStateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChange^>(info.This())) {
        return;
      }

      MobileBroadbandPinLockStateChange *wrapper = MobileBroadbandPinLockStateChange::Unwrap<MobileBroadbandPinLockStateChange>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::MobileBroadbandPinLockState result = wrapper->_instance->PinLockState;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PinTypeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChange^>(info.This())) {
        return;
      }

      MobileBroadbandPinLockStateChange *wrapper = MobileBroadbandPinLockStateChange::Unwrap<MobileBroadbandPinLockStateChange>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::MobileBroadbandPinType result = wrapper->_instance->PinType;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChange^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandPinLockStateChange(::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChange^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChange^ UnwrapMobileBroadbandPinLockStateChange(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandPinLockStateChange::s_constructorTemplate;

  v8::Local<v8::Value> WrapMobileBroadbandPinLockStateChange(::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChange^ 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>(MobileBroadbandPinLockStateChange::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChange^ UnwrapMobileBroadbandPinLockStateChange(Local<Value> value) {
     return MobileBroadbandPinLockStateChange::Unwrap<MobileBroadbandPinLockStateChange>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandPinLockStateChange(Local<Object> exports) {
    MobileBroadbandPinLockStateChange::Init(exports);
  }

  class MobileBroadbandPinLockStateChangeTriggerDetails : 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>("MobileBroadbandPinLockStateChangeTriggerDetails").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pinLockStateChanges").ToLocalChecked(), PinLockStateChangesGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("MobileBroadbandPinLockStateChangeTriggerDetails").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      MobileBroadbandPinLockStateChangeTriggerDetails(::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChangeTriggerDetails^ 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::NetworkOperators::MobileBroadbandPinLockStateChangeTriggerDetails^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChangeTriggerDetails^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChangeTriggerDetails^) 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());

      MobileBroadbandPinLockStateChangeTriggerDetails *wrapperInstance = new MobileBroadbandPinLockStateChangeTriggerDetails(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::NetworkOperators::MobileBroadbandPinLockStateChangeTriggerDetails^>(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::NetworkOperators::MobileBroadbandPinLockStateChangeTriggerDetails^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChangeTriggerDetails^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapMobileBroadbandPinLockStateChangeTriggerDetails(winRtInstance));
    }





    static void PinLockStateChangesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChangeTriggerDetails^>(info.This())) {
        return;
      }

      MobileBroadbandPinLockStateChangeTriggerDetails *wrapper = MobileBroadbandPinLockStateChangeTriggerDetails::Unwrap<MobileBroadbandPinLockStateChangeTriggerDetails>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChange^>^ result = wrapper->_instance->PinLockStateChanges;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChange^>::CreateVectorViewWrapper(result, 
            [](::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChange^ val) -> Local<Value> {
              return WrapMobileBroadbandPinLockStateChange(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChange^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChange^ {
              return UnwrapMobileBroadbandPinLockStateChange(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChangeTriggerDetails^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandPinLockStateChangeTriggerDetails(::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChangeTriggerDetails^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChangeTriggerDetails^ UnwrapMobileBroadbandPinLockStateChangeTriggerDetails(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandPinLockStateChangeTriggerDetails::s_constructorTemplate;

  v8::Local<v8::Value> WrapMobileBroadbandPinLockStateChangeTriggerDetails(::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChangeTriggerDetails^ 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>(MobileBroadbandPinLockStateChangeTriggerDetails::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::MobileBroadbandPinLockStateChangeTriggerDetails^ UnwrapMobileBroadbandPinLockStateChangeTriggerDetails(Local<Value> value) {
     return MobileBroadbandPinLockStateChangeTriggerDetails::Unwrap<MobileBroadbandPinLockStateChangeTriggerDetails>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandPinLockStateChangeTriggerDetails(Local<Object> exports) {
    MobileBroadbandPinLockStateChangeTriggerDetails::Init(exports);
  }

  class MobileBroadbandDeviceServiceTriggerDetails : 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>("MobileBroadbandDeviceServiceTriggerDetails").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("deviceId").ToLocalChecked(), DeviceIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("deviceServiceId").ToLocalChecked(), DeviceServiceIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("receivedData").ToLocalChecked(), ReceivedDataGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("MobileBroadbandDeviceServiceTriggerDetails").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      MobileBroadbandDeviceServiceTriggerDetails(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceTriggerDetails^ 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::NetworkOperators::MobileBroadbandDeviceServiceTriggerDetails^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceTriggerDetails^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceTriggerDetails^) 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());

      MobileBroadbandDeviceServiceTriggerDetails *wrapperInstance = new MobileBroadbandDeviceServiceTriggerDetails(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::NetworkOperators::MobileBroadbandDeviceServiceTriggerDetails^>(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::NetworkOperators::MobileBroadbandDeviceServiceTriggerDetails^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceTriggerDetails^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapMobileBroadbandDeviceServiceTriggerDetails(winRtInstance));
    }





    static void DeviceIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceTriggerDetails^>(info.This())) {
        return;
      }

      MobileBroadbandDeviceServiceTriggerDetails *wrapper = MobileBroadbandDeviceServiceTriggerDetails::Unwrap<MobileBroadbandDeviceServiceTriggerDetails>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->DeviceId;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DeviceServiceIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceTriggerDetails^>(info.This())) {
        return;
      }

      MobileBroadbandDeviceServiceTriggerDetails *wrapper = MobileBroadbandDeviceServiceTriggerDetails::Unwrap<MobileBroadbandDeviceServiceTriggerDetails>(info.This());

      try  {
        ::Platform::Guid result = wrapper->_instance->DeviceServiceId;
        info.GetReturnValue().Set(NodeRT::Utils::GuidToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ReceivedDataGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceTriggerDetails^>(info.This())) {
        return;
      }

      MobileBroadbandDeviceServiceTriggerDetails *wrapper = MobileBroadbandDeviceServiceTriggerDetails::Unwrap<MobileBroadbandDeviceServiceTriggerDetails>(info.This());

      try  {
        ::Windows::Storage::Streams::IBuffer^ result = wrapper->_instance->ReceivedData;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Storage.Streams", "IBuffer", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceTriggerDetails^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandDeviceServiceTriggerDetails(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceTriggerDetails^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceTriggerDetails^ UnwrapMobileBroadbandDeviceServiceTriggerDetails(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandDeviceServiceTriggerDetails::s_constructorTemplate;

  v8::Local<v8::Value> WrapMobileBroadbandDeviceServiceTriggerDetails(::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceTriggerDetails^ 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>(MobileBroadbandDeviceServiceTriggerDetails::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::MobileBroadbandDeviceServiceTriggerDetails^ UnwrapMobileBroadbandDeviceServiceTriggerDetails(Local<Value> value) {
     return MobileBroadbandDeviceServiceTriggerDetails::Unwrap<MobileBroadbandDeviceServiceTriggerDetails>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandDeviceServiceTriggerDetails(Local<Object> exports) {
    MobileBroadbandDeviceServiceTriggerDetails::Init(exports);
  }

  class KnownCSimFilePaths : 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>("KnownCSimFilePaths").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);






        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetAccessor(constructor, Nan::New<String>("eFSpn").ToLocalChecked(), EFSpnGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("gid1").ToLocalChecked(), Gid1Getter);
        Nan::SetAccessor(constructor, Nan::New<String>("gid2").ToLocalChecked(), Gid2Getter);


        Nan::Set(exports, Nan::New<String>("KnownCSimFilePaths").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      KnownCSimFilePaths(::Windows::Networking::NetworkOperators::KnownCSimFilePaths^ 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::NetworkOperators::KnownCSimFilePaths^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::KnownCSimFilePaths^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::KnownCSimFilePaths^) 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());

      KnownCSimFilePaths *wrapperInstance = new KnownCSimFilePaths(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::NetworkOperators::KnownCSimFilePaths^>(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::NetworkOperators::KnownCSimFilePaths^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::KnownCSimFilePaths^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapKnownCSimFilePaths(winRtInstance));
    }







    static void EFSpnGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::Foundation::Collections::IVectorView<unsigned int>^ result = ::Windows::Networking::NetworkOperators::KnownCSimFilePaths::EFSpn;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned int>::CreateVectorViewWrapper(result, 
            [](unsigned int val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsUint32();
            },
            [](Local<Value> value) -> unsigned int {
              return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void Gid1Getter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::Foundation::Collections::IVectorView<unsigned int>^ result = ::Windows::Networking::NetworkOperators::KnownCSimFilePaths::Gid1;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned int>::CreateVectorViewWrapper(result, 
            [](unsigned int val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsUint32();
            },
            [](Local<Value> value) -> unsigned int {
              return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void Gid2Getter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::Foundation::Collections::IVectorView<unsigned int>^ result = ::Windows::Networking::NetworkOperators::KnownCSimFilePaths::Gid2;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned int>::CreateVectorViewWrapper(result, 
            [](unsigned int val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsUint32();
            },
            [](Local<Value> value) -> unsigned int {
              return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    private:
      ::Windows::Networking::NetworkOperators::KnownCSimFilePaths^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapKnownCSimFilePaths(::Windows::Networking::NetworkOperators::KnownCSimFilePaths^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::KnownCSimFilePaths^ UnwrapKnownCSimFilePaths(Local<Value> value);
  };

  Persistent<FunctionTemplate> KnownCSimFilePaths::s_constructorTemplate;

  v8::Local<v8::Value> WrapKnownCSimFilePaths(::Windows::Networking::NetworkOperators::KnownCSimFilePaths^ 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>(KnownCSimFilePaths::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::KnownCSimFilePaths^ UnwrapKnownCSimFilePaths(Local<Value> value) {
     return KnownCSimFilePaths::Unwrap<KnownCSimFilePaths>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitKnownCSimFilePaths(Local<Object> exports) {
    KnownCSimFilePaths::Init(exports);
  }

  class KnownRuimFilePaths : 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>("KnownRuimFilePaths").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);






        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetAccessor(constructor, Nan::New<String>("eFSpn").ToLocalChecked(), EFSpnGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("gid1").ToLocalChecked(), Gid1Getter);
        Nan::SetAccessor(constructor, Nan::New<String>("gid2").ToLocalChecked(), Gid2Getter);


        Nan::Set(exports, Nan::New<String>("KnownRuimFilePaths").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      KnownRuimFilePaths(::Windows::Networking::NetworkOperators::KnownRuimFilePaths^ 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::NetworkOperators::KnownRuimFilePaths^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::KnownRuimFilePaths^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::KnownRuimFilePaths^) 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());

      KnownRuimFilePaths *wrapperInstance = new KnownRuimFilePaths(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::NetworkOperators::KnownRuimFilePaths^>(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::NetworkOperators::KnownRuimFilePaths^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::KnownRuimFilePaths^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapKnownRuimFilePaths(winRtInstance));
    }







    static void EFSpnGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::Foundation::Collections::IVectorView<unsigned int>^ result = ::Windows::Networking::NetworkOperators::KnownRuimFilePaths::EFSpn;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned int>::CreateVectorViewWrapper(result, 
            [](unsigned int val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsUint32();
            },
            [](Local<Value> value) -> unsigned int {
              return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void Gid1Getter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::Foundation::Collections::IVectorView<unsigned int>^ result = ::Windows::Networking::NetworkOperators::KnownRuimFilePaths::Gid1;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned int>::CreateVectorViewWrapper(result, 
            [](unsigned int val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsUint32();
            },
            [](Local<Value> value) -> unsigned int {
              return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void Gid2Getter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::Foundation::Collections::IVectorView<unsigned int>^ result = ::Windows::Networking::NetworkOperators::KnownRuimFilePaths::Gid2;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned int>::CreateVectorViewWrapper(result, 
            [](unsigned int val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsUint32();
            },
            [](Local<Value> value) -> unsigned int {
              return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    private:
      ::Windows::Networking::NetworkOperators::KnownRuimFilePaths^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapKnownRuimFilePaths(::Windows::Networking::NetworkOperators::KnownRuimFilePaths^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::KnownRuimFilePaths^ UnwrapKnownRuimFilePaths(Local<Value> value);
  };

  Persistent<FunctionTemplate> KnownRuimFilePaths::s_constructorTemplate;

  v8::Local<v8::Value> WrapKnownRuimFilePaths(::Windows::Networking::NetworkOperators::KnownRuimFilePaths^ 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>(KnownRuimFilePaths::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::KnownRuimFilePaths^ UnwrapKnownRuimFilePaths(Local<Value> value) {
     return KnownRuimFilePaths::Unwrap<KnownRuimFilePaths>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitKnownRuimFilePaths(Local<Object> exports) {
    KnownRuimFilePaths::Init(exports);
  }

  class KnownSimFilePaths : 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>("KnownSimFilePaths").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);






        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetAccessor(constructor, Nan::New<String>("eFOns").ToLocalChecked(), EFOnsGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("eFSpn").ToLocalChecked(), EFSpnGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("gid1").ToLocalChecked(), Gid1Getter);
        Nan::SetAccessor(constructor, Nan::New<String>("gid2").ToLocalChecked(), Gid2Getter);


        Nan::Set(exports, Nan::New<String>("KnownSimFilePaths").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      KnownSimFilePaths(::Windows::Networking::NetworkOperators::KnownSimFilePaths^ 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::NetworkOperators::KnownSimFilePaths^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::KnownSimFilePaths^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::KnownSimFilePaths^) 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());

      KnownSimFilePaths *wrapperInstance = new KnownSimFilePaths(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::NetworkOperators::KnownSimFilePaths^>(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::NetworkOperators::KnownSimFilePaths^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::KnownSimFilePaths^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapKnownSimFilePaths(winRtInstance));
    }







    static void EFOnsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::Foundation::Collections::IVectorView<unsigned int>^ result = ::Windows::Networking::NetworkOperators::KnownSimFilePaths::EFOns;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned int>::CreateVectorViewWrapper(result, 
            [](unsigned int val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsUint32();
            },
            [](Local<Value> value) -> unsigned int {
              return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void EFSpnGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::Foundation::Collections::IVectorView<unsigned int>^ result = ::Windows::Networking::NetworkOperators::KnownSimFilePaths::EFSpn;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned int>::CreateVectorViewWrapper(result, 
            [](unsigned int val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsUint32();
            },
            [](Local<Value> value) -> unsigned int {
              return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void Gid1Getter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::Foundation::Collections::IVectorView<unsigned int>^ result = ::Windows::Networking::NetworkOperators::KnownSimFilePaths::Gid1;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned int>::CreateVectorViewWrapper(result, 
            [](unsigned int val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsUint32();
            },
            [](Local<Value> value) -> unsigned int {
              return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void Gid2Getter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::Foundation::Collections::IVectorView<unsigned int>^ result = ::Windows::Networking::NetworkOperators::KnownSimFilePaths::Gid2;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned int>::CreateVectorViewWrapper(result, 
            [](unsigned int val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsUint32();
            },
            [](Local<Value> value) -> unsigned int {
              return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    private:
      ::Windows::Networking::NetworkOperators::KnownSimFilePaths^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapKnownSimFilePaths(::Windows::Networking::NetworkOperators::KnownSimFilePaths^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::KnownSimFilePaths^ UnwrapKnownSimFilePaths(Local<Value> value);
  };

  Persistent<FunctionTemplate> KnownSimFilePaths::s_constructorTemplate;

  v8::Local<v8::Value> WrapKnownSimFilePaths(::Windows::Networking::NetworkOperators::KnownSimFilePaths^ 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>(KnownSimFilePaths::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::KnownSimFilePaths^ UnwrapKnownSimFilePaths(Local<Value> value) {
     return KnownSimFilePaths::Unwrap<KnownSimFilePaths>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitKnownSimFilePaths(Local<Object> exports) {
    KnownSimFilePaths::Init(exports);
  }

  class KnownUSimFilePaths : 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>("KnownUSimFilePaths").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);






        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetAccessor(constructor, Nan::New<String>("eFOpl").ToLocalChecked(), EFOplGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("eFPnn").ToLocalChecked(), EFPnnGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("eFSpn").ToLocalChecked(), EFSpnGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("gid1").ToLocalChecked(), Gid1Getter);
        Nan::SetAccessor(constructor, Nan::New<String>("gid2").ToLocalChecked(), Gid2Getter);


        Nan::Set(exports, Nan::New<String>("KnownUSimFilePaths").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      KnownUSimFilePaths(::Windows::Networking::NetworkOperators::KnownUSimFilePaths^ 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::NetworkOperators::KnownUSimFilePaths^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::KnownUSimFilePaths^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::KnownUSimFilePaths^) 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());

      KnownUSimFilePaths *wrapperInstance = new KnownUSimFilePaths(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::NetworkOperators::KnownUSimFilePaths^>(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::NetworkOperators::KnownUSimFilePaths^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::KnownUSimFilePaths^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapKnownUSimFilePaths(winRtInstance));
    }







    static void EFOplGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::Foundation::Collections::IVectorView<unsigned int>^ result = ::Windows::Networking::NetworkOperators::KnownUSimFilePaths::EFOpl;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned int>::CreateVectorViewWrapper(result, 
            [](unsigned int val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsUint32();
            },
            [](Local<Value> value) -> unsigned int {
              return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void EFPnnGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::Foundation::Collections::IVectorView<unsigned int>^ result = ::Windows::Networking::NetworkOperators::KnownUSimFilePaths::EFPnn;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned int>::CreateVectorViewWrapper(result, 
            [](unsigned int val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsUint32();
            },
            [](Local<Value> value) -> unsigned int {
              return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void EFSpnGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::Foundation::Collections::IVectorView<unsigned int>^ result = ::Windows::Networking::NetworkOperators::KnownUSimFilePaths::EFSpn;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned int>::CreateVectorViewWrapper(result, 
            [](unsigned int val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsUint32();
            },
            [](Local<Value> value) -> unsigned int {
              return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void Gid1Getter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::Foundation::Collections::IVectorView<unsigned int>^ result = ::Windows::Networking::NetworkOperators::KnownUSimFilePaths::Gid1;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned int>::CreateVectorViewWrapper(result, 
            [](unsigned int val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsUint32();
            },
            [](Local<Value> value) -> unsigned int {
              return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void Gid2Getter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::Foundation::Collections::IVectorView<unsigned int>^ result = ::Windows::Networking::NetworkOperators::KnownUSimFilePaths::Gid2;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<unsigned int>::CreateVectorViewWrapper(result, 
            [](unsigned int val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsUint32();
            },
            [](Local<Value> value) -> unsigned int {
              return static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    private:
      ::Windows::Networking::NetworkOperators::KnownUSimFilePaths^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapKnownUSimFilePaths(::Windows::Networking::NetworkOperators::KnownUSimFilePaths^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::KnownUSimFilePaths^ UnwrapKnownUSimFilePaths(Local<Value> value);
  };

  Persistent<FunctionTemplate> KnownUSimFilePaths::s_constructorTemplate;

  v8::Local<v8::Value> WrapKnownUSimFilePaths(::Windows::Networking::NetworkOperators::KnownUSimFilePaths^ 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>(KnownUSimFilePaths::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::KnownUSimFilePaths^ UnwrapKnownUSimFilePaths(Local<Value> value) {
     return KnownUSimFilePaths::Unwrap<KnownUSimFilePaths>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitKnownUSimFilePaths(Local<Object> exports) {
    KnownUSimFilePaths::Init(exports);
  }

  class MobileBroadbandCellCdma : 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>("MobileBroadbandCellCdma").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("baseStationId").ToLocalChecked(), BaseStationIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("baseStationLastBroadcastGpsTime").ToLocalChecked(), BaseStationLastBroadcastGpsTimeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("baseStationLatitude").ToLocalChecked(), BaseStationLatitudeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("baseStationLongitude").ToLocalChecked(), BaseStationLongitudeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("baseStationPNCode").ToLocalChecked(), BaseStationPNCodeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("networkId").ToLocalChecked(), NetworkIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pilotSignalStrengthInDB").ToLocalChecked(), PilotSignalStrengthInDBGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("systemId").ToLocalChecked(), SystemIdGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("MobileBroadbandCellCdma").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      MobileBroadbandCellCdma(::Windows::Networking::NetworkOperators::MobileBroadbandCellCdma^ 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::NetworkOperators::MobileBroadbandCellCdma^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellCdma^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandCellCdma^) 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());

      MobileBroadbandCellCdma *wrapperInstance = new MobileBroadbandCellCdma(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::NetworkOperators::MobileBroadbandCellCdma^>(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::NetworkOperators::MobileBroadbandCellCdma^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandCellCdma^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapMobileBroadbandCellCdma(winRtInstance));
    }





    static void BaseStationIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellCdma^>(info.This())) {
        return;
      }

      MobileBroadbandCellCdma *wrapper = MobileBroadbandCellCdma::Unwrap<MobileBroadbandCellCdma>(info.This());

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->BaseStationId;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BaseStationLastBroadcastGpsTimeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellCdma^>(info.This())) {
        return;
      }

      MobileBroadbandCellCdma *wrapper = MobileBroadbandCellCdma::Unwrap<MobileBroadbandCellCdma>(info.This());

      try  {
        ::Platform::IBox<::Windows::Foundation::TimeSpan>^ result = wrapper->_instance->BaseStationLastBroadcastGpsTime;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Number>(result->Value.Duration/10000.0)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BaseStationLatitudeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellCdma^>(info.This())) {
        return;
      }

      MobileBroadbandCellCdma *wrapper = MobileBroadbandCellCdma::Unwrap<MobileBroadbandCellCdma>(info.This());

      try  {
        ::Platform::IBox<double>^ result = wrapper->_instance->BaseStationLatitude;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Number>(static_cast<double>(result->Value))) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BaseStationLongitudeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellCdma^>(info.This())) {
        return;
      }

      MobileBroadbandCellCdma *wrapper = MobileBroadbandCellCdma::Unwrap<MobileBroadbandCellCdma>(info.This());

      try  {
        ::Platform::IBox<double>^ result = wrapper->_instance->BaseStationLongitude;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Number>(static_cast<double>(result->Value))) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BaseStationPNCodeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellCdma^>(info.This())) {
        return;
      }

      MobileBroadbandCellCdma *wrapper = MobileBroadbandCellCdma::Unwrap<MobileBroadbandCellCdma>(info.This());

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->BaseStationPNCode;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void NetworkIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellCdma^>(info.This())) {
        return;
      }

      MobileBroadbandCellCdma *wrapper = MobileBroadbandCellCdma::Unwrap<MobileBroadbandCellCdma>(info.This());

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->NetworkId;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PilotSignalStrengthInDBGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellCdma^>(info.This())) {
        return;
      }

      MobileBroadbandCellCdma *wrapper = MobileBroadbandCellCdma::Unwrap<MobileBroadbandCellCdma>(info.This());

      try  {
        ::Platform::IBox<double>^ result = wrapper->_instance->PilotSignalStrengthInDB;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Number>(static_cast<double>(result->Value))) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SystemIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellCdma^>(info.This())) {
        return;
      }

      MobileBroadbandCellCdma *wrapper = MobileBroadbandCellCdma::Unwrap<MobileBroadbandCellCdma>(info.This());

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->SystemId;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandCellCdma^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandCellCdma(::Windows::Networking::NetworkOperators::MobileBroadbandCellCdma^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandCellCdma^ UnwrapMobileBroadbandCellCdma(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandCellCdma::s_constructorTemplate;

  v8::Local<v8::Value> WrapMobileBroadbandCellCdma(::Windows::Networking::NetworkOperators::MobileBroadbandCellCdma^ 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>(MobileBroadbandCellCdma::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::MobileBroadbandCellCdma^ UnwrapMobileBroadbandCellCdma(Local<Value> value) {
     return MobileBroadbandCellCdma::Unwrap<MobileBroadbandCellCdma>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandCellCdma(Local<Object> exports) {
    MobileBroadbandCellCdma::Init(exports);
  }

  class MobileBroadbandCellGsm : 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>("MobileBroadbandCellGsm").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("baseStationId").ToLocalChecked(), BaseStationIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("cellId").ToLocalChecked(), CellIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("channelNumber").ToLocalChecked(), ChannelNumberGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("locationAreaCode").ToLocalChecked(), LocationAreaCodeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("providerId").ToLocalChecked(), ProviderIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("receivedSignalStrengthInDBm").ToLocalChecked(), ReceivedSignalStrengthInDBmGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("timingAdvanceInBitPeriods").ToLocalChecked(), TimingAdvanceInBitPeriodsGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("MobileBroadbandCellGsm").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      MobileBroadbandCellGsm(::Windows::Networking::NetworkOperators::MobileBroadbandCellGsm^ 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::NetworkOperators::MobileBroadbandCellGsm^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellGsm^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandCellGsm^) 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());

      MobileBroadbandCellGsm *wrapperInstance = new MobileBroadbandCellGsm(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::NetworkOperators::MobileBroadbandCellGsm^>(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::NetworkOperators::MobileBroadbandCellGsm^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandCellGsm^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapMobileBroadbandCellGsm(winRtInstance));
    }





    static void BaseStationIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellGsm^>(info.This())) {
        return;
      }

      MobileBroadbandCellGsm *wrapper = MobileBroadbandCellGsm::Unwrap<MobileBroadbandCellGsm>(info.This());

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->BaseStationId;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CellIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellGsm^>(info.This())) {
        return;
      }

      MobileBroadbandCellGsm *wrapper = MobileBroadbandCellGsm::Unwrap<MobileBroadbandCellGsm>(info.This());

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->CellId;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ChannelNumberGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellGsm^>(info.This())) {
        return;
      }

      MobileBroadbandCellGsm *wrapper = MobileBroadbandCellGsm::Unwrap<MobileBroadbandCellGsm>(info.This());

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->ChannelNumber;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void LocationAreaCodeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellGsm^>(info.This())) {
        return;
      }

      MobileBroadbandCellGsm *wrapper = MobileBroadbandCellGsm::Unwrap<MobileBroadbandCellGsm>(info.This());

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->LocationAreaCode;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ProviderIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellGsm^>(info.This())) {
        return;
      }

      MobileBroadbandCellGsm *wrapper = MobileBroadbandCellGsm::Unwrap<MobileBroadbandCellGsm>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->ProviderId;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ReceivedSignalStrengthInDBmGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellGsm^>(info.This())) {
        return;
      }

      MobileBroadbandCellGsm *wrapper = MobileBroadbandCellGsm::Unwrap<MobileBroadbandCellGsm>(info.This());

      try  {
        ::Platform::IBox<double>^ result = wrapper->_instance->ReceivedSignalStrengthInDBm;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Number>(static_cast<double>(result->Value))) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TimingAdvanceInBitPeriodsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellGsm^>(info.This())) {
        return;
      }

      MobileBroadbandCellGsm *wrapper = MobileBroadbandCellGsm::Unwrap<MobileBroadbandCellGsm>(info.This());

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->TimingAdvanceInBitPeriods;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandCellGsm^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandCellGsm(::Windows::Networking::NetworkOperators::MobileBroadbandCellGsm^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandCellGsm^ UnwrapMobileBroadbandCellGsm(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandCellGsm::s_constructorTemplate;

  v8::Local<v8::Value> WrapMobileBroadbandCellGsm(::Windows::Networking::NetworkOperators::MobileBroadbandCellGsm^ 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>(MobileBroadbandCellGsm::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::MobileBroadbandCellGsm^ UnwrapMobileBroadbandCellGsm(Local<Value> value) {
     return MobileBroadbandCellGsm::Unwrap<MobileBroadbandCellGsm>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandCellGsm(Local<Object> exports) {
    MobileBroadbandCellGsm::Init(exports);
  }

  class MobileBroadbandCellLte : 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>("MobileBroadbandCellLte").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("cellId").ToLocalChecked(), CellIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("channelNumber").ToLocalChecked(), ChannelNumberGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("physicalCellId").ToLocalChecked(), PhysicalCellIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("providerId").ToLocalChecked(), ProviderIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("referenceSignalReceivedPowerInDBm").ToLocalChecked(), ReferenceSignalReceivedPowerInDBmGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("referenceSignalReceivedQualityInDBm").ToLocalChecked(), ReferenceSignalReceivedQualityInDBmGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("timingAdvanceInBitPeriods").ToLocalChecked(), TimingAdvanceInBitPeriodsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("trackingAreaCode").ToLocalChecked(), TrackingAreaCodeGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("MobileBroadbandCellLte").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      MobileBroadbandCellLte(::Windows::Networking::NetworkOperators::MobileBroadbandCellLte^ 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::NetworkOperators::MobileBroadbandCellLte^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellLte^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandCellLte^) 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());

      MobileBroadbandCellLte *wrapperInstance = new MobileBroadbandCellLte(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::NetworkOperators::MobileBroadbandCellLte^>(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::NetworkOperators::MobileBroadbandCellLte^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandCellLte^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapMobileBroadbandCellLte(winRtInstance));
    }





    static void CellIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellLte^>(info.This())) {
        return;
      }

      MobileBroadbandCellLte *wrapper = MobileBroadbandCellLte::Unwrap<MobileBroadbandCellLte>(info.This());

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->CellId;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ChannelNumberGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellLte^>(info.This())) {
        return;
      }

      MobileBroadbandCellLte *wrapper = MobileBroadbandCellLte::Unwrap<MobileBroadbandCellLte>(info.This());

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->ChannelNumber;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PhysicalCellIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellLte^>(info.This())) {
        return;
      }

      MobileBroadbandCellLte *wrapper = MobileBroadbandCellLte::Unwrap<MobileBroadbandCellLte>(info.This());

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->PhysicalCellId;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ProviderIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellLte^>(info.This())) {
        return;
      }

      MobileBroadbandCellLte *wrapper = MobileBroadbandCellLte::Unwrap<MobileBroadbandCellLte>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->ProviderId;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ReferenceSignalReceivedPowerInDBmGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellLte^>(info.This())) {
        return;
      }

      MobileBroadbandCellLte *wrapper = MobileBroadbandCellLte::Unwrap<MobileBroadbandCellLte>(info.This());

      try  {
        ::Platform::IBox<double>^ result = wrapper->_instance->ReferenceSignalReceivedPowerInDBm;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Number>(static_cast<double>(result->Value))) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ReferenceSignalReceivedQualityInDBmGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellLte^>(info.This())) {
        return;
      }

      MobileBroadbandCellLte *wrapper = MobileBroadbandCellLte::Unwrap<MobileBroadbandCellLte>(info.This());

      try  {
        ::Platform::IBox<double>^ result = wrapper->_instance->ReferenceSignalReceivedQualityInDBm;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Number>(static_cast<double>(result->Value))) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TimingAdvanceInBitPeriodsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellLte^>(info.This())) {
        return;
      }

      MobileBroadbandCellLte *wrapper = MobileBroadbandCellLte::Unwrap<MobileBroadbandCellLte>(info.This());

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->TimingAdvanceInBitPeriods;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TrackingAreaCodeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellLte^>(info.This())) {
        return;
      }

      MobileBroadbandCellLte *wrapper = MobileBroadbandCellLte::Unwrap<MobileBroadbandCellLte>(info.This());

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->TrackingAreaCode;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandCellLte^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandCellLte(::Windows::Networking::NetworkOperators::MobileBroadbandCellLte^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandCellLte^ UnwrapMobileBroadbandCellLte(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandCellLte::s_constructorTemplate;

  v8::Local<v8::Value> WrapMobileBroadbandCellLte(::Windows::Networking::NetworkOperators::MobileBroadbandCellLte^ 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>(MobileBroadbandCellLte::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::MobileBroadbandCellLte^ UnwrapMobileBroadbandCellLte(Local<Value> value) {
     return MobileBroadbandCellLte::Unwrap<MobileBroadbandCellLte>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandCellLte(Local<Object> exports) {
    MobileBroadbandCellLte::Init(exports);
  }

  class MobileBroadbandCellTdscdma : 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>("MobileBroadbandCellTdscdma").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("cellId").ToLocalChecked(), CellIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("cellParameterId").ToLocalChecked(), CellParameterIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("channelNumber").ToLocalChecked(), ChannelNumberGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("locationAreaCode").ToLocalChecked(), LocationAreaCodeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pathLossInDB").ToLocalChecked(), PathLossInDBGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("providerId").ToLocalChecked(), ProviderIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("receivedSignalCodePowerInDBm").ToLocalChecked(), ReceivedSignalCodePowerInDBmGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("timingAdvanceInBitPeriods").ToLocalChecked(), TimingAdvanceInBitPeriodsGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("MobileBroadbandCellTdscdma").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      MobileBroadbandCellTdscdma(::Windows::Networking::NetworkOperators::MobileBroadbandCellTdscdma^ 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::NetworkOperators::MobileBroadbandCellTdscdma^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellTdscdma^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandCellTdscdma^) 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());

      MobileBroadbandCellTdscdma *wrapperInstance = new MobileBroadbandCellTdscdma(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::NetworkOperators::MobileBroadbandCellTdscdma^>(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::NetworkOperators::MobileBroadbandCellTdscdma^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandCellTdscdma^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapMobileBroadbandCellTdscdma(winRtInstance));
    }





    static void CellIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellTdscdma^>(info.This())) {
        return;
      }

      MobileBroadbandCellTdscdma *wrapper = MobileBroadbandCellTdscdma::Unwrap<MobileBroadbandCellTdscdma>(info.This());

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->CellId;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CellParameterIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellTdscdma^>(info.This())) {
        return;
      }

      MobileBroadbandCellTdscdma *wrapper = MobileBroadbandCellTdscdma::Unwrap<MobileBroadbandCellTdscdma>(info.This());

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->CellParameterId;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ChannelNumberGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellTdscdma^>(info.This())) {
        return;
      }

      MobileBroadbandCellTdscdma *wrapper = MobileBroadbandCellTdscdma::Unwrap<MobileBroadbandCellTdscdma>(info.This());

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->ChannelNumber;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void LocationAreaCodeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellTdscdma^>(info.This())) {
        return;
      }

      MobileBroadbandCellTdscdma *wrapper = MobileBroadbandCellTdscdma::Unwrap<MobileBroadbandCellTdscdma>(info.This());

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->LocationAreaCode;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PathLossInDBGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellTdscdma^>(info.This())) {
        return;
      }

      MobileBroadbandCellTdscdma *wrapper = MobileBroadbandCellTdscdma::Unwrap<MobileBroadbandCellTdscdma>(info.This());

      try  {
        ::Platform::IBox<double>^ result = wrapper->_instance->PathLossInDB;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Number>(static_cast<double>(result->Value))) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ProviderIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellTdscdma^>(info.This())) {
        return;
      }

      MobileBroadbandCellTdscdma *wrapper = MobileBroadbandCellTdscdma::Unwrap<MobileBroadbandCellTdscdma>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->ProviderId;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ReceivedSignalCodePowerInDBmGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellTdscdma^>(info.This())) {
        return;
      }

      MobileBroadbandCellTdscdma *wrapper = MobileBroadbandCellTdscdma::Unwrap<MobileBroadbandCellTdscdma>(info.This());

      try  {
        ::Platform::IBox<double>^ result = wrapper->_instance->ReceivedSignalCodePowerInDBm;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Number>(static_cast<double>(result->Value))) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TimingAdvanceInBitPeriodsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellTdscdma^>(info.This())) {
        return;
      }

      MobileBroadbandCellTdscdma *wrapper = MobileBroadbandCellTdscdma::Unwrap<MobileBroadbandCellTdscdma>(info.This());

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->TimingAdvanceInBitPeriods;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandCellTdscdma^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandCellTdscdma(::Windows::Networking::NetworkOperators::MobileBroadbandCellTdscdma^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandCellTdscdma^ UnwrapMobileBroadbandCellTdscdma(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandCellTdscdma::s_constructorTemplate;

  v8::Local<v8::Value> WrapMobileBroadbandCellTdscdma(::Windows::Networking::NetworkOperators::MobileBroadbandCellTdscdma^ 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>(MobileBroadbandCellTdscdma::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::MobileBroadbandCellTdscdma^ UnwrapMobileBroadbandCellTdscdma(Local<Value> value) {
     return MobileBroadbandCellTdscdma::Unwrap<MobileBroadbandCellTdscdma>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandCellTdscdma(Local<Object> exports) {
    MobileBroadbandCellTdscdma::Init(exports);
  }

  class MobileBroadbandCellUmts : 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>("MobileBroadbandCellUmts").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("cellId").ToLocalChecked(), CellIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("channelNumber").ToLocalChecked(), ChannelNumberGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("locationAreaCode").ToLocalChecked(), LocationAreaCodeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pathLossInDB").ToLocalChecked(), PathLossInDBGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("primaryScramblingCode").ToLocalChecked(), PrimaryScramblingCodeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("providerId").ToLocalChecked(), ProviderIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("receivedSignalCodePowerInDBm").ToLocalChecked(), ReceivedSignalCodePowerInDBmGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("signalToNoiseRatioInDB").ToLocalChecked(), SignalToNoiseRatioInDBGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("MobileBroadbandCellUmts").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      MobileBroadbandCellUmts(::Windows::Networking::NetworkOperators::MobileBroadbandCellUmts^ 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::NetworkOperators::MobileBroadbandCellUmts^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellUmts^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandCellUmts^) 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());

      MobileBroadbandCellUmts *wrapperInstance = new MobileBroadbandCellUmts(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::NetworkOperators::MobileBroadbandCellUmts^>(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::NetworkOperators::MobileBroadbandCellUmts^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandCellUmts^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapMobileBroadbandCellUmts(winRtInstance));
    }





    static void CellIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellUmts^>(info.This())) {
        return;
      }

      MobileBroadbandCellUmts *wrapper = MobileBroadbandCellUmts::Unwrap<MobileBroadbandCellUmts>(info.This());

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->CellId;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ChannelNumberGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellUmts^>(info.This())) {
        return;
      }

      MobileBroadbandCellUmts *wrapper = MobileBroadbandCellUmts::Unwrap<MobileBroadbandCellUmts>(info.This());

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->ChannelNumber;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void LocationAreaCodeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellUmts^>(info.This())) {
        return;
      }

      MobileBroadbandCellUmts *wrapper = MobileBroadbandCellUmts::Unwrap<MobileBroadbandCellUmts>(info.This());

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->LocationAreaCode;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PathLossInDBGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellUmts^>(info.This())) {
        return;
      }

      MobileBroadbandCellUmts *wrapper = MobileBroadbandCellUmts::Unwrap<MobileBroadbandCellUmts>(info.This());

      try  {
        ::Platform::IBox<double>^ result = wrapper->_instance->PathLossInDB;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Number>(static_cast<double>(result->Value))) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PrimaryScramblingCodeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellUmts^>(info.This())) {
        return;
      }

      MobileBroadbandCellUmts *wrapper = MobileBroadbandCellUmts::Unwrap<MobileBroadbandCellUmts>(info.This());

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->PrimaryScramblingCode;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ProviderIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellUmts^>(info.This())) {
        return;
      }

      MobileBroadbandCellUmts *wrapper = MobileBroadbandCellUmts::Unwrap<MobileBroadbandCellUmts>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->ProviderId;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ReceivedSignalCodePowerInDBmGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellUmts^>(info.This())) {
        return;
      }

      MobileBroadbandCellUmts *wrapper = MobileBroadbandCellUmts::Unwrap<MobileBroadbandCellUmts>(info.This());

      try  {
        ::Platform::IBox<double>^ result = wrapper->_instance->ReceivedSignalCodePowerInDBm;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Number>(static_cast<double>(result->Value))) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SignalToNoiseRatioInDBGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandCellUmts^>(info.This())) {
        return;
      }

      MobileBroadbandCellUmts *wrapper = MobileBroadbandCellUmts::Unwrap<MobileBroadbandCellUmts>(info.This());

      try  {
        ::Platform::IBox<double>^ result = wrapper->_instance->SignalToNoiseRatioInDB;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Number>(static_cast<double>(result->Value))) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandCellUmts^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandCellUmts(::Windows::Networking::NetworkOperators::MobileBroadbandCellUmts^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandCellUmts^ UnwrapMobileBroadbandCellUmts(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandCellUmts::s_constructorTemplate;

  v8::Local<v8::Value> WrapMobileBroadbandCellUmts(::Windows::Networking::NetworkOperators::MobileBroadbandCellUmts^ 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>(MobileBroadbandCellUmts::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::MobileBroadbandCellUmts^ UnwrapMobileBroadbandCellUmts(Local<Value> value) {
     return MobileBroadbandCellUmts::Unwrap<MobileBroadbandCellUmts>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandCellUmts(Local<Object> exports) {
    MobileBroadbandCellUmts::Init(exports);
  }

  class MobileBroadbandModemIsolation : 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>("MobileBroadbandModemIsolation").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);

        Local<Function> func;
        Local<FunctionTemplate> funcTemplate;

          
            Nan::SetPrototypeMethod(localRef, "addAllowedHost", AddAllowedHost);
            Nan::SetPrototypeMethod(localRef, "addAllowedHostRange", AddAllowedHostRange);
          

          
            Nan::SetPrototypeMethod(localRef, "applyConfigurationAsync", ApplyConfigurationAsync);
            Nan::SetPrototypeMethod(localRef, "clearConfigurationAsync", ClearConfigurationAsync);
          



        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("MobileBroadbandModemIsolation").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      MobileBroadbandModemIsolation(::Windows::Networking::NetworkOperators::MobileBroadbandModemIsolation^ 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::NetworkOperators::MobileBroadbandModemIsolation^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandModemIsolation^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandModemIsolation^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && info[0]->IsString()
        && info[1]->IsString())
      {
        try {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          
          winRtInstance = ref new ::Windows::Networking::NetworkOperators::MobileBroadbandModemIsolation(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());

      MobileBroadbandModemIsolation *wrapperInstance = new MobileBroadbandModemIsolation(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::NetworkOperators::MobileBroadbandModemIsolation^>(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::NetworkOperators::MobileBroadbandModemIsolation^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandModemIsolation^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapMobileBroadbandModemIsolation(winRtInstance));
    }

    static void ApplyConfigurationAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandModemIsolation^>(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;
      }

      MobileBroadbandModemIsolation *wrapper = MobileBroadbandModemIsolation::Unwrap<MobileBroadbandModemIsolation>(info.This());

      ::Windows::Foundation::IAsyncAction^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->ApplyConfigurationAsync();
        }
        catch (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 ClearConfigurationAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandModemIsolation^>(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;
      }

      MobileBroadbandModemIsolation *wrapper = MobileBroadbandModemIsolation::Unwrap<MobileBroadbandModemIsolation>(info.This());

      ::Windows::Foundation::IAsyncAction^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->ClearConfigurationAsync();
        }
        catch (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 AddAllowedHost(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandModemIsolation^>(info.This())) {
        return;
      }

      MobileBroadbandModemIsolation *wrapper = MobileBroadbandModemIsolation::Unwrap<MobileBroadbandModemIsolation>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::HostName^>(info[0]))
      {
        try
        {
          ::Windows::Networking::HostName^ arg0 = dynamic_cast<::Windows::Networking::HostName^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          wrapper->_instance->AddAllowedHost(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 AddAllowedHostRange(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandModemIsolation^>(info.This())) {
        return;
      }

      MobileBroadbandModemIsolation *wrapper = MobileBroadbandModemIsolation::Unwrap<MobileBroadbandModemIsolation>(info.This());

      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::HostName^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::HostName^>(info[1]))
      {
        try
        {
          ::Windows::Networking::HostName^ arg0 = dynamic_cast<::Windows::Networking::HostName^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Networking::HostName^ arg1 = dynamic_cast<::Windows::Networking::HostName^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          wrapper->_instance->AddAllowedHostRange(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::NetworkOperators::MobileBroadbandModemIsolation^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandModemIsolation(::Windows::Networking::NetworkOperators::MobileBroadbandModemIsolation^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandModemIsolation^ UnwrapMobileBroadbandModemIsolation(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandModemIsolation::s_constructorTemplate;

  v8::Local<v8::Value> WrapMobileBroadbandModemIsolation(::Windows::Networking::NetworkOperators::MobileBroadbandModemIsolation^ 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>(MobileBroadbandModemIsolation::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::MobileBroadbandModemIsolation^ UnwrapMobileBroadbandModemIsolation(Local<Value> value) {
     return MobileBroadbandModemIsolation::Unwrap<MobileBroadbandModemIsolation>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandModemIsolation(Local<Object> exports) {
    MobileBroadbandModemIsolation::Init(exports);
  }

  class MobileBroadbandPcoDataChangeTriggerDetails : 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>("MobileBroadbandPcoDataChangeTriggerDetails").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("updatedData").ToLocalChecked(), UpdatedDataGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("MobileBroadbandPcoDataChangeTriggerDetails").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      MobileBroadbandPcoDataChangeTriggerDetails(::Windows::Networking::NetworkOperators::MobileBroadbandPcoDataChangeTriggerDetails^ 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::NetworkOperators::MobileBroadbandPcoDataChangeTriggerDetails^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandPcoDataChangeTriggerDetails^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandPcoDataChangeTriggerDetails^) 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());

      MobileBroadbandPcoDataChangeTriggerDetails *wrapperInstance = new MobileBroadbandPcoDataChangeTriggerDetails(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::NetworkOperators::MobileBroadbandPcoDataChangeTriggerDetails^>(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::NetworkOperators::MobileBroadbandPcoDataChangeTriggerDetails^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandPcoDataChangeTriggerDetails^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapMobileBroadbandPcoDataChangeTriggerDetails(winRtInstance));
    }





    static void UpdatedDataGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandPcoDataChangeTriggerDetails^>(info.This())) {
        return;
      }

      MobileBroadbandPcoDataChangeTriggerDetails *wrapper = MobileBroadbandPcoDataChangeTriggerDetails::Unwrap<MobileBroadbandPcoDataChangeTriggerDetails>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::MobileBroadbandPco^ result = wrapper->_instance->UpdatedData;
        info.GetReturnValue().Set(WrapMobileBroadbandPco(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandPcoDataChangeTriggerDetails^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandPcoDataChangeTriggerDetails(::Windows::Networking::NetworkOperators::MobileBroadbandPcoDataChangeTriggerDetails^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandPcoDataChangeTriggerDetails^ UnwrapMobileBroadbandPcoDataChangeTriggerDetails(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandPcoDataChangeTriggerDetails::s_constructorTemplate;

  v8::Local<v8::Value> WrapMobileBroadbandPcoDataChangeTriggerDetails(::Windows::Networking::NetworkOperators::MobileBroadbandPcoDataChangeTriggerDetails^ 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>(MobileBroadbandPcoDataChangeTriggerDetails::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::MobileBroadbandPcoDataChangeTriggerDetails^ UnwrapMobileBroadbandPcoDataChangeTriggerDetails(Local<Value> value) {
     return MobileBroadbandPcoDataChangeTriggerDetails::Unwrap<MobileBroadbandPcoDataChangeTriggerDetails>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandPcoDataChangeTriggerDetails(Local<Object> exports) {
    MobileBroadbandPcoDataChangeTriggerDetails::Init(exports);
  }

  class MobileBroadbandAntennaSar : 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>("MobileBroadbandAntennaSar").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("antennaIndex").ToLocalChecked(), AntennaIndexGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("sarBackoffIndex").ToLocalChecked(), SarBackoffIndexGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("MobileBroadbandAntennaSar").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      MobileBroadbandAntennaSar(::Windows::Networking::NetworkOperators::MobileBroadbandAntennaSar^ 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::NetworkOperators::MobileBroadbandAntennaSar^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandAntennaSar^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandAntennaSar^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && info[0]->IsInt32()
        && info[1]->IsInt32())
      {
        try {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          int arg1 = static_cast<int>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          winRtInstance = ref new ::Windows::Networking::NetworkOperators::MobileBroadbandAntennaSar(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());

      MobileBroadbandAntennaSar *wrapperInstance = new MobileBroadbandAntennaSar(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::NetworkOperators::MobileBroadbandAntennaSar^>(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::NetworkOperators::MobileBroadbandAntennaSar^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandAntennaSar^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapMobileBroadbandAntennaSar(winRtInstance));
    }





    static void AntennaIndexGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandAntennaSar^>(info.This())) {
        return;
      }

      MobileBroadbandAntennaSar *wrapper = MobileBroadbandAntennaSar::Unwrap<MobileBroadbandAntennaSar>(info.This());

      try  {
        int result = wrapper->_instance->AntennaIndex;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SarBackoffIndexGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandAntennaSar^>(info.This())) {
        return;
      }

      MobileBroadbandAntennaSar *wrapper = MobileBroadbandAntennaSar::Unwrap<MobileBroadbandAntennaSar>(info.This());

      try  {
        int result = wrapper->_instance->SarBackoffIndex;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandAntennaSar^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandAntennaSar(::Windows::Networking::NetworkOperators::MobileBroadbandAntennaSar^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandAntennaSar^ UnwrapMobileBroadbandAntennaSar(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandAntennaSar::s_constructorTemplate;

  v8::Local<v8::Value> WrapMobileBroadbandAntennaSar(::Windows::Networking::NetworkOperators::MobileBroadbandAntennaSar^ 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>(MobileBroadbandAntennaSar::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::MobileBroadbandAntennaSar^ UnwrapMobileBroadbandAntennaSar(Local<Value> value) {
     return MobileBroadbandAntennaSar::Unwrap<MobileBroadbandAntennaSar>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandAntennaSar(Local<Object> exports) {
    MobileBroadbandAntennaSar::Init(exports);
  }

  class MobileBroadbandTransmissionStateChangedEventArgs : 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>("MobileBroadbandTransmissionStateChangedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isTransmitting").ToLocalChecked(), IsTransmittingGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("MobileBroadbandTransmissionStateChangedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      MobileBroadbandTransmissionStateChangedEventArgs(::Windows::Networking::NetworkOperators::MobileBroadbandTransmissionStateChangedEventArgs^ 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::NetworkOperators::MobileBroadbandTransmissionStateChangedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandTransmissionStateChangedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandTransmissionStateChangedEventArgs^) 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());

      MobileBroadbandTransmissionStateChangedEventArgs *wrapperInstance = new MobileBroadbandTransmissionStateChangedEventArgs(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::NetworkOperators::MobileBroadbandTransmissionStateChangedEventArgs^>(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::NetworkOperators::MobileBroadbandTransmissionStateChangedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::MobileBroadbandTransmissionStateChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapMobileBroadbandTransmissionStateChangedEventArgs(winRtInstance));
    }





    static void IsTransmittingGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::MobileBroadbandTransmissionStateChangedEventArgs^>(info.This())) {
        return;
      }

      MobileBroadbandTransmissionStateChangedEventArgs *wrapper = MobileBroadbandTransmissionStateChangedEventArgs::Unwrap<MobileBroadbandTransmissionStateChangedEventArgs>(info.This());

      try  {
        bool result = wrapper->_instance->IsTransmitting;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::MobileBroadbandTransmissionStateChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMobileBroadbandTransmissionStateChangedEventArgs(::Windows::Networking::NetworkOperators::MobileBroadbandTransmissionStateChangedEventArgs^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::MobileBroadbandTransmissionStateChangedEventArgs^ UnwrapMobileBroadbandTransmissionStateChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> MobileBroadbandTransmissionStateChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapMobileBroadbandTransmissionStateChangedEventArgs(::Windows::Networking::NetworkOperators::MobileBroadbandTransmissionStateChangedEventArgs^ 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>(MobileBroadbandTransmissionStateChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::MobileBroadbandTransmissionStateChangedEventArgs^ UnwrapMobileBroadbandTransmissionStateChangedEventArgs(Local<Value> value) {
     return MobileBroadbandTransmissionStateChangedEventArgs::Unwrap<MobileBroadbandTransmissionStateChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMobileBroadbandTransmissionStateChangedEventArgs(Local<Object> exports) {
    MobileBroadbandTransmissionStateChangedEventArgs::Init(exports);
  }

  class ESimPolicy : 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>("ESimPolicy").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("shouldEnableManagingUi").ToLocalChecked(), ShouldEnableManagingUiGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ESimPolicy").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ESimPolicy(::Windows::Networking::NetworkOperators::ESimPolicy^ 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::NetworkOperators::ESimPolicy^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimPolicy^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::ESimPolicy^) 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());

      ESimPolicy *wrapperInstance = new ESimPolicy(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::NetworkOperators::ESimPolicy^>(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::NetworkOperators::ESimPolicy^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::ESimPolicy^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapESimPolicy(winRtInstance));
    }





    static void ShouldEnableManagingUiGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimPolicy^>(info.This())) {
        return;
      }

      ESimPolicy *wrapper = ESimPolicy::Unwrap<ESimPolicy>(info.This());

      try  {
        bool result = wrapper->_instance->ShouldEnableManagingUi;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::ESimPolicy^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapESimPolicy(::Windows::Networking::NetworkOperators::ESimPolicy^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::ESimPolicy^ UnwrapESimPolicy(Local<Value> value);
  };

  Persistent<FunctionTemplate> ESimPolicy::s_constructorTemplate;

  v8::Local<v8::Value> WrapESimPolicy(::Windows::Networking::NetworkOperators::ESimPolicy^ 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>(ESimPolicy::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::ESimPolicy^ UnwrapESimPolicy(Local<Value> value) {
     return ESimPolicy::Unwrap<ESimPolicy>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitESimPolicy(Local<Object> exports) {
    ESimPolicy::Init(exports);
  }

  class ESimProfile : 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>("ESimProfile").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);

        Local<Function> func;
        Local<FunctionTemplate> funcTemplate;


          
            Nan::SetPrototypeMethod(localRef, "disableAsync", DisableAsync);
            Nan::SetPrototypeMethod(localRef, "enableAsync", EnableAsync);
            Nan::SetPrototypeMethod(localRef, "setNicknameAsync", SetNicknameAsync);
          


          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("class").ToLocalChecked(), ClassGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("id").ToLocalChecked(), IdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("nickname").ToLocalChecked(), NicknameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("policy").ToLocalChecked(), PolicyGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("providerIcon").ToLocalChecked(), ProviderIconGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("providerId").ToLocalChecked(), ProviderIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("providerName").ToLocalChecked(), ProviderNameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("state").ToLocalChecked(), StateGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ESimProfile").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ESimProfile(::Windows::Networking::NetworkOperators::ESimProfile^ 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::NetworkOperators::ESimProfile^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfile^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::ESimProfile^) 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());

      ESimProfile *wrapperInstance = new ESimProfile(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::NetworkOperators::ESimProfile^>(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::NetworkOperators::ESimProfile^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::ESimProfile^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapESimProfile(winRtInstance));
    }

    static void DisableAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfile^>(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;
      }

      ESimProfile *wrapper = ESimProfile::Unwrap<ESimProfile>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::NetworkOperators::ESimOperationResult^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->DisableAsync();
        }
        catch (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::NetworkOperators::ESimOperationResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapESimOperationResult(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 EnableAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfile^>(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;
      }

      ESimProfile *wrapper = ESimProfile::Unwrap<ESimProfile>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::NetworkOperators::ESimOperationResult^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->EnableAsync();
        }
        catch (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::NetworkOperators::ESimOperationResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapESimOperationResult(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 SetNicknameAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfile^>(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;
      }

      ESimProfile *wrapper = ESimProfile::Unwrap<ESimProfile>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::NetworkOperators::ESimOperationResult^>^ 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->SetNicknameAsync(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::NetworkOperators::ESimOperationResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapESimOperationResult(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 ClassGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfile^>(info.This())) {
        return;
      }

      ESimProfile *wrapper = ESimProfile::Unwrap<ESimProfile>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::ESimProfileClass result = wrapper->_instance->Class;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(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::NetworkOperators::ESimProfile^>(info.This())) {
        return;
      }

      ESimProfile *wrapper = ESimProfile::Unwrap<ESimProfile>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Id;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void NicknameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfile^>(info.This())) {
        return;
      }

      ESimProfile *wrapper = ESimProfile::Unwrap<ESimProfile>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Nickname;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PolicyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfile^>(info.This())) {
        return;
      }

      ESimProfile *wrapper = ESimProfile::Unwrap<ESimProfile>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::ESimProfilePolicy^ result = wrapper->_instance->Policy;
        info.GetReturnValue().Set(WrapESimProfilePolicy(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ProviderIconGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfile^>(info.This())) {
        return;
      }

      ESimProfile *wrapper = ESimProfile::Unwrap<ESimProfile>(info.This());

      try  {
        ::Windows::Storage::Streams::IRandomAccessStreamReference^ result = wrapper->_instance->ProviderIcon;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Storage.Streams", "IRandomAccessStreamReference", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ProviderIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfile^>(info.This())) {
        return;
      }

      ESimProfile *wrapper = ESimProfile::Unwrap<ESimProfile>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->ProviderId;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ProviderNameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfile^>(info.This())) {
        return;
      }

      ESimProfile *wrapper = ESimProfile::Unwrap<ESimProfile>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->ProviderName;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void StateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfile^>(info.This())) {
        return;
      }

      ESimProfile *wrapper = ESimProfile::Unwrap<ESimProfile>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::ESimProfileState result = wrapper->_instance->State;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::ESimProfile^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapESimProfile(::Windows::Networking::NetworkOperators::ESimProfile^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::ESimProfile^ UnwrapESimProfile(Local<Value> value);
  };

  Persistent<FunctionTemplate> ESimProfile::s_constructorTemplate;

  v8::Local<v8::Value> WrapESimProfile(::Windows::Networking::NetworkOperators::ESimProfile^ 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>(ESimProfile::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::ESimProfile^ UnwrapESimProfile(Local<Value> value) {
     return ESimProfile::Unwrap<ESimProfile>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitESimProfile(Local<Object> exports) {
    ESimProfile::Init(exports);
  }

  class ESimOperationResult : 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>("ESimOperationResult").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("status").ToLocalChecked(), StatusGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ESimOperationResult").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ESimOperationResult(::Windows::Networking::NetworkOperators::ESimOperationResult^ 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::NetworkOperators::ESimOperationResult^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimOperationResult^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::ESimOperationResult^) 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());

      ESimOperationResult *wrapperInstance = new ESimOperationResult(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::NetworkOperators::ESimOperationResult^>(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::NetworkOperators::ESimOperationResult^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::ESimOperationResult^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapESimOperationResult(winRtInstance));
    }





    static void StatusGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimOperationResult^>(info.This())) {
        return;
      }

      ESimOperationResult *wrapper = ESimOperationResult::Unwrap<ESimOperationResult>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::ESimOperationStatus result = wrapper->_instance->Status;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::ESimOperationResult^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapESimOperationResult(::Windows::Networking::NetworkOperators::ESimOperationResult^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::ESimOperationResult^ UnwrapESimOperationResult(Local<Value> value);
  };

  Persistent<FunctionTemplate> ESimOperationResult::s_constructorTemplate;

  v8::Local<v8::Value> WrapESimOperationResult(::Windows::Networking::NetworkOperators::ESimOperationResult^ 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>(ESimOperationResult::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::ESimOperationResult^ UnwrapESimOperationResult(Local<Value> value) {
     return ESimOperationResult::Unwrap<ESimOperationResult>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitESimOperationResult(Local<Object> exports) {
    ESimOperationResult::Init(exports);
  }

  class ESimDownloadProfileMetadataResult : 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>("ESimDownloadProfileMetadataResult").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("profileMetadata").ToLocalChecked(), ProfileMetadataGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("result").ToLocalChecked(), ResultGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ESimDownloadProfileMetadataResult").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ESimDownloadProfileMetadataResult(::Windows::Networking::NetworkOperators::ESimDownloadProfileMetadataResult^ 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::NetworkOperators::ESimDownloadProfileMetadataResult^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimDownloadProfileMetadataResult^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::ESimDownloadProfileMetadataResult^) 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());

      ESimDownloadProfileMetadataResult *wrapperInstance = new ESimDownloadProfileMetadataResult(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::NetworkOperators::ESimDownloadProfileMetadataResult^>(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::NetworkOperators::ESimDownloadProfileMetadataResult^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::ESimDownloadProfileMetadataResult^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapESimDownloadProfileMetadataResult(winRtInstance));
    }





    static void ProfileMetadataGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimDownloadProfileMetadataResult^>(info.This())) {
        return;
      }

      ESimDownloadProfileMetadataResult *wrapper = ESimDownloadProfileMetadataResult::Unwrap<ESimDownloadProfileMetadataResult>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::ESimProfileMetadata^ result = wrapper->_instance->ProfileMetadata;
        info.GetReturnValue().Set(WrapESimProfileMetadata(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ResultGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimDownloadProfileMetadataResult^>(info.This())) {
        return;
      }

      ESimDownloadProfileMetadataResult *wrapper = ESimDownloadProfileMetadataResult::Unwrap<ESimDownloadProfileMetadataResult>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::ESimOperationResult^ result = wrapper->_instance->Result;
        info.GetReturnValue().Set(WrapESimOperationResult(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::ESimDownloadProfileMetadataResult^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapESimDownloadProfileMetadataResult(::Windows::Networking::NetworkOperators::ESimDownloadProfileMetadataResult^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::ESimDownloadProfileMetadataResult^ UnwrapESimDownloadProfileMetadataResult(Local<Value> value);
  };

  Persistent<FunctionTemplate> ESimDownloadProfileMetadataResult::s_constructorTemplate;

  v8::Local<v8::Value> WrapESimDownloadProfileMetadataResult(::Windows::Networking::NetworkOperators::ESimDownloadProfileMetadataResult^ 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>(ESimDownloadProfileMetadataResult::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::ESimDownloadProfileMetadataResult^ UnwrapESimDownloadProfileMetadataResult(Local<Value> value) {
     return ESimDownloadProfileMetadataResult::Unwrap<ESimDownloadProfileMetadataResult>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitESimDownloadProfileMetadataResult(Local<Object> exports) {
    ESimDownloadProfileMetadataResult::Init(exports);
  }

  class ESim : 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>("ESim").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);

        Local<Function> func;
        Local<FunctionTemplate> funcTemplate;

          
            Nan::SetPrototypeMethod(localRef, "getProfiles", GetProfiles);
          

          
            Nan::SetPrototypeMethod(localRef, "deleteProfileAsync", DeleteProfileAsync);
            Nan::SetPrototypeMethod(localRef, "downloadProfileMetadataAsync", DownloadProfileMetadataAsync);
            Nan::SetPrototypeMethod(localRef, "resetAsync", ResetAsync);
          

          
          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>("availableMemoryInBytes").ToLocalChecked(), AvailableMemoryInBytesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("eid").ToLocalChecked(), EidGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("firmwareVersion").ToLocalChecked(), FirmwareVersionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("mobileBroadbandModemDeviceId").ToLocalChecked(), MobileBroadbandModemDeviceIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("policy").ToLocalChecked(), PolicyGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("state").ToLocalChecked(), StateGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ESim").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ESim(::Windows::Networking::NetworkOperators::ESim^ 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::NetworkOperators::ESim^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESim^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::ESim^) 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());

      ESim *wrapperInstance = new ESim(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::NetworkOperators::ESim^>(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::NetworkOperators::ESim^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::ESim^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapESim(winRtInstance));
    }

    static void DeleteProfileAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESim^>(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;
      }

      ESim *wrapper = ESim::Unwrap<ESim>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::NetworkOperators::ESimOperationResult^>^ 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->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::NetworkOperators::ESimOperationResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapESimOperationResult(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 DownloadProfileMetadataAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESim^>(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;
      }

      ESim *wrapper = ESim::Unwrap<ESim>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::NetworkOperators::ESimDownloadProfileMetadataResult^>^ 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->DownloadProfileMetadataAsync(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::NetworkOperators::ESimDownloadProfileMetadataResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapESimDownloadProfileMetadataResult(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 ResetAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESim^>(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;
      }

      ESim *wrapper = ESim::Unwrap<ESim>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::NetworkOperators::ESimOperationResult^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->ResetAsync();
        }
        catch (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::NetworkOperators::ESimOperationResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapESimOperationResult(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 GetProfiles(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESim^>(info.This())) {
        return;
      }

      ESim *wrapper = ESim::Unwrap<ESim>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Windows::Networking::NetworkOperators::ESimProfile^>^ result;
          result = wrapper->_instance->GetProfiles();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Networking::NetworkOperators::ESimProfile^>::CreateVectorViewWrapper(result, 
            [](::Windows::Networking::NetworkOperators::ESimProfile^ val) -> Local<Value> {
              return WrapESimProfile(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfile^>(value);
            },
            [](Local<Value> value) -> ::Windows::Networking::NetworkOperators::ESimProfile^ {
              return UnwrapESimProfile(value);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    static void AvailableMemoryInBytesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESim^>(info.This())) {
        return;
      }

      ESim *wrapper = ESim::Unwrap<ESim>(info.This());

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->AvailableMemoryInBytes;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void EidGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESim^>(info.This())) {
        return;
      }

      ESim *wrapper = ESim::Unwrap<ESim>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Eid;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void FirmwareVersionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESim^>(info.This())) {
        return;
      }

      ESim *wrapper = ESim::Unwrap<ESim>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->FirmwareVersion;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MobileBroadbandModemDeviceIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESim^>(info.This())) {
        return;
      }

      ESim *wrapper = ESim::Unwrap<ESim>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->MobileBroadbandModemDeviceId;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PolicyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESim^>(info.This())) {
        return;
      }

      ESim *wrapper = ESim::Unwrap<ESim>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::ESimPolicy^ result = wrapper->_instance->Policy;
        info.GetReturnValue().Set(WrapESimPolicy(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void StateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESim^>(info.This())) {
        return;
      }

      ESim *wrapper = ESim::Unwrap<ESim>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::ESimState result = wrapper->_instance->State;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    static void 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"profileChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESim^>(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;
        }
        ESim *wrapper = ESim::Unwrap<ESim>(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->ProfileChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Networking::NetworkOperators::ESim^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Networking::NetworkOperators::ESim^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapESim(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
 else  {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Value> tokenMapVal = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());
      Local<Object> tokenMap;

      if (tokenMapVal.IsEmpty() || Nan::Equals(tokenMapVal, Undefined()).FromMaybe(false)) {
        tokenMap = Nan::New<Object>();
        NodeRT::Utils::SetHiddenValueWithObject(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked(), tokenMap);
      } else {
        tokenMap = Nan::To<Object>(tokenMapVal).ToLocalChecked();
      }

      Nan::Set(tokenMap, info[0], CreateOpaqueWrapper(::Windows::Foundation::PropertyValue::CreateInt64(registrationToken.Value)));
    }

    static void RemoveListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected a string and a callback")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      if ((!NodeRT::Utils::CaseInsenstiveEquals(L"profileChanged", 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"profileChanged", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESim^>(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;
          }
          ESim *wrapper = ESim::Unwrap<ESim>(info.This());
          wrapper->_instance->ProfileChanged::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::NetworkOperators::ESim^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapESim(::Windows::Networking::NetworkOperators::ESim^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::ESim^ UnwrapESim(Local<Value> value);
  };

  Persistent<FunctionTemplate> ESim::s_constructorTemplate;

  v8::Local<v8::Value> WrapESim(::Windows::Networking::NetworkOperators::ESim^ 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>(ESim::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::ESim^ UnwrapESim(Local<Value> value) {
     return ESim::Unwrap<ESim>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitESim(Local<Object> exports) {
    ESim::Init(exports);
  }

  class ESimAddedEventArgs : 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>("ESimAddedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("eSim").ToLocalChecked(), ESimGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ESimAddedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ESimAddedEventArgs(::Windows::Networking::NetworkOperators::ESimAddedEventArgs^ 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::NetworkOperators::ESimAddedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimAddedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::ESimAddedEventArgs^) 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());

      ESimAddedEventArgs *wrapperInstance = new ESimAddedEventArgs(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::NetworkOperators::ESimAddedEventArgs^>(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::NetworkOperators::ESimAddedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::ESimAddedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapESimAddedEventArgs(winRtInstance));
    }





    static void ESimGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimAddedEventArgs^>(info.This())) {
        return;
      }

      ESimAddedEventArgs *wrapper = ESimAddedEventArgs::Unwrap<ESimAddedEventArgs>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::ESim^ result = wrapper->_instance->ESim;
        info.GetReturnValue().Set(WrapESim(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::ESimAddedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapESimAddedEventArgs(::Windows::Networking::NetworkOperators::ESimAddedEventArgs^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::ESimAddedEventArgs^ UnwrapESimAddedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> ESimAddedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapESimAddedEventArgs(::Windows::Networking::NetworkOperators::ESimAddedEventArgs^ 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>(ESimAddedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::ESimAddedEventArgs^ UnwrapESimAddedEventArgs(Local<Value> value) {
     return ESimAddedEventArgs::Unwrap<ESimAddedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitESimAddedEventArgs(Local<Object> exports) {
    ESimAddedEventArgs::Init(exports);
  }

  class ESimProfileMetadata : 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>("ESimProfileMetadata").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);

        Local<Function> func;
        Local<FunctionTemplate> funcTemplate;


          
            Nan::SetPrototypeMethod(localRef, "denyInstallAsync", DenyInstallAsync);
            Nan::SetPrototypeMethod(localRef, "confirmInstallAsync", ConfirmInstallAsync);
            Nan::SetPrototypeMethod(localRef, "postponeInstallAsync", PostponeInstallAsync);
          

          
          Nan::SetPrototypeMethod(localRef,"addListener", AddListener);
          Nan::SetPrototypeMethod(localRef,"on", AddListener);
          Nan::SetPrototypeMethod(localRef,"removeListener", RemoveListener);
          Nan::SetPrototypeMethod(localRef, "off", RemoveListener);

          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("id").ToLocalChecked(), IdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isConfirmationCodeRequired").ToLocalChecked(), IsConfirmationCodeRequiredGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("policy").ToLocalChecked(), PolicyGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("providerIcon").ToLocalChecked(), ProviderIconGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("providerId").ToLocalChecked(), ProviderIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("providerName").ToLocalChecked(), ProviderNameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("state").ToLocalChecked(), StateGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ESimProfileMetadata").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ESimProfileMetadata(::Windows::Networking::NetworkOperators::ESimProfileMetadata^ 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::NetworkOperators::ESimProfileMetadata^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfileMetadata^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::ESimProfileMetadata^) 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());

      ESimProfileMetadata *wrapperInstance = new ESimProfileMetadata(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::NetworkOperators::ESimProfileMetadata^>(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::NetworkOperators::ESimProfileMetadata^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::ESimProfileMetadata^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapESimProfileMetadata(winRtInstance));
    }

    static void DenyInstallAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfileMetadata^>(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;
      }

      ESimProfileMetadata *wrapper = ESimProfileMetadata::Unwrap<ESimProfileMetadata>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::NetworkOperators::ESimOperationResult^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->DenyInstallAsync();
        }
        catch (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::NetworkOperators::ESimOperationResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapESimOperationResult(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 ConfirmInstallAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfileMetadata^>(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;
      }

      ESimProfileMetadata *wrapper = ESimProfileMetadata::Unwrap<ESimProfileMetadata>(info.This());

      ::Windows::Foundation::IAsyncOperationWithProgress<::Windows::Networking::NetworkOperators::ESimOperationResult^, ::Windows::Networking::NetworkOperators::ESimProfileInstallProgress>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->ConfirmInstallAsync();
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else 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->ConfirmInstallAsync(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::NetworkOperators::ESimOperationResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapESimOperationResult(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 PostponeInstallAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfileMetadata^>(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;
      }

      ESimProfileMetadata *wrapper = ESimProfileMetadata::Unwrap<ESimProfileMetadata>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::NetworkOperators::ESimOperationResult^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->PostponeInstallAsync();
        }
        catch (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::NetworkOperators::ESimOperationResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapESimOperationResult(result);
              if (tryCatch.HasCaught())
              {
                error = Nan::To<Object>(tryCatch.Exception()).ToLocalChecked();
              }
              else
              {
                error = Undefined();
              }
              if (arg1.IsEmpty()) arg1 = Undefined();
            }
            Local<Value> args[] = {error, arg1};


            invokeCallback(_countof(args), args);
          });
        } catch (Platform::Exception^ exception) {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {
            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

            Local<Value> args[] = {error};
            invokeCallback(_countof(args), args);
          });
        }
      });
    }




    static void IdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfileMetadata^>(info.This())) {
        return;
      }

      ESimProfileMetadata *wrapper = ESimProfileMetadata::Unwrap<ESimProfileMetadata>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Id;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsConfirmationCodeRequiredGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfileMetadata^>(info.This())) {
        return;
      }

      ESimProfileMetadata *wrapper = ESimProfileMetadata::Unwrap<ESimProfileMetadata>(info.This());

      try  {
        bool result = wrapper->_instance->IsConfirmationCodeRequired;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PolicyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfileMetadata^>(info.This())) {
        return;
      }

      ESimProfileMetadata *wrapper = ESimProfileMetadata::Unwrap<ESimProfileMetadata>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::ESimProfilePolicy^ result = wrapper->_instance->Policy;
        info.GetReturnValue().Set(WrapESimProfilePolicy(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ProviderIconGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfileMetadata^>(info.This())) {
        return;
      }

      ESimProfileMetadata *wrapper = ESimProfileMetadata::Unwrap<ESimProfileMetadata>(info.This());

      try  {
        ::Windows::Storage::Streams::IRandomAccessStreamReference^ result = wrapper->_instance->ProviderIcon;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Storage.Streams", "IRandomAccessStreamReference", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ProviderIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfileMetadata^>(info.This())) {
        return;
      }

      ESimProfileMetadata *wrapper = ESimProfileMetadata::Unwrap<ESimProfileMetadata>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->ProviderId;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ProviderNameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfileMetadata^>(info.This())) {
        return;
      }

      ESimProfileMetadata *wrapper = ESimProfileMetadata::Unwrap<ESimProfileMetadata>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->ProviderName;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void StateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfileMetadata^>(info.This())) {
        return;
      }

      ESimProfileMetadata *wrapper = ESimProfileMetadata::Unwrap<ESimProfileMetadata>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::ESimProfileMetadataState result = wrapper->_instance->State;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    static void 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"stateChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfileMetadata^>(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;
        }
        ESimProfileMetadata *wrapper = ESimProfileMetadata::Unwrap<ESimProfileMetadata>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->StateChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Networking::NetworkOperators::ESimProfileMetadata^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Networking::NetworkOperators::ESimProfileMetadata^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapESimProfileMetadata(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
 else  {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Value> tokenMapVal = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());
      Local<Object> tokenMap;

      if (tokenMapVal.IsEmpty() || Nan::Equals(tokenMapVal, Undefined()).FromMaybe(false)) {
        tokenMap = Nan::New<Object>();
        NodeRT::Utils::SetHiddenValueWithObject(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked(), tokenMap);
      } else {
        tokenMap = Nan::To<Object>(tokenMapVal).ToLocalChecked();
      }

      Nan::Set(tokenMap, info[0], CreateOpaqueWrapper(::Windows::Foundation::PropertyValue::CreateInt64(registrationToken.Value)));
    }

    static void RemoveListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected a string and a callback")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      if ((!NodeRT::Utils::CaseInsenstiveEquals(L"stateChanged", 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"stateChanged", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfileMetadata^>(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;
          }
          ESimProfileMetadata *wrapper = ESimProfileMetadata::Unwrap<ESimProfileMetadata>(info.This());
          wrapper->_instance->StateChanged::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::NetworkOperators::ESimProfileMetadata^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapESimProfileMetadata(::Windows::Networking::NetworkOperators::ESimProfileMetadata^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::ESimProfileMetadata^ UnwrapESimProfileMetadata(Local<Value> value);
  };

  Persistent<FunctionTemplate> ESimProfileMetadata::s_constructorTemplate;

  v8::Local<v8::Value> WrapESimProfileMetadata(::Windows::Networking::NetworkOperators::ESimProfileMetadata^ 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>(ESimProfileMetadata::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::ESimProfileMetadata^ UnwrapESimProfileMetadata(Local<Value> value) {
     return ESimProfileMetadata::Unwrap<ESimProfileMetadata>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitESimProfileMetadata(Local<Object> exports) {
    ESimProfileMetadata::Init(exports);
  }

  class ESimServiceInfo : 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>("ESimServiceInfo").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("authenticationPreference").ToLocalChecked(), AuthenticationPreferenceGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isESimUiEnabled").ToLocalChecked(), IsESimUiEnabledGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ESimServiceInfo").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ESimServiceInfo(::Windows::Networking::NetworkOperators::ESimServiceInfo^ 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::NetworkOperators::ESimServiceInfo^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimServiceInfo^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::ESimServiceInfo^) 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());

      ESimServiceInfo *wrapperInstance = new ESimServiceInfo(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::NetworkOperators::ESimServiceInfo^>(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::NetworkOperators::ESimServiceInfo^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::ESimServiceInfo^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapESimServiceInfo(winRtInstance));
    }





    static void AuthenticationPreferenceGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimServiceInfo^>(info.This())) {
        return;
      }

      ESimServiceInfo *wrapper = ESimServiceInfo::Unwrap<ESimServiceInfo>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::ESimAuthenticationPreference result = wrapper->_instance->AuthenticationPreference;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsESimUiEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimServiceInfo^>(info.This())) {
        return;
      }

      ESimServiceInfo *wrapper = ESimServiceInfo::Unwrap<ESimServiceInfo>(info.This());

      try  {
        bool result = wrapper->_instance->IsESimUiEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::ESimServiceInfo^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapESimServiceInfo(::Windows::Networking::NetworkOperators::ESimServiceInfo^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::ESimServiceInfo^ UnwrapESimServiceInfo(Local<Value> value);
  };

  Persistent<FunctionTemplate> ESimServiceInfo::s_constructorTemplate;

  v8::Local<v8::Value> WrapESimServiceInfo(::Windows::Networking::NetworkOperators::ESimServiceInfo^ 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>(ESimServiceInfo::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::ESimServiceInfo^ UnwrapESimServiceInfo(Local<Value> value) {
     return ESimServiceInfo::Unwrap<ESimServiceInfo>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitESimServiceInfo(Local<Object> exports) {
    ESimServiceInfo::Init(exports);
  }

  class ESimWatcher : 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>("ESimWatcher").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "start", Start);
            Nan::SetPrototypeMethod(localRef, "stop", Stop);
          


          
          Nan::SetPrototypeMethod(localRef,"addListener", AddListener);
          Nan::SetPrototypeMethod(localRef,"on", AddListener);
          Nan::SetPrototypeMethod(localRef,"removeListener", RemoveListener);
          Nan::SetPrototypeMethod(localRef, "off", RemoveListener);

          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("status").ToLocalChecked(), StatusGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ESimWatcher").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ESimWatcher(::Windows::Networking::NetworkOperators::ESimWatcher^ 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::NetworkOperators::ESimWatcher^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimWatcher^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::ESimWatcher^) 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());

      ESimWatcher *wrapperInstance = new ESimWatcher(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::NetworkOperators::ESimWatcher^>(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::NetworkOperators::ESimWatcher^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::ESimWatcher^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapESimWatcher(winRtInstance));
    }


    static void Start(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimWatcher^>(info.This())) {
        return;
      }

      ESimWatcher *wrapper = ESimWatcher::Unwrap<ESimWatcher>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->Start();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void Stop(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimWatcher^>(info.This())) {
        return;
      }

      ESimWatcher *wrapper = ESimWatcher::Unwrap<ESimWatcher>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->Stop();
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    static void StatusGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimWatcher^>(info.This())) {
        return;
      }

      ESimWatcher *wrapper = ESimWatcher::Unwrap<ESimWatcher>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::ESimWatcherStatus result = wrapper->_instance->Status;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    static void AddListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"added", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimWatcher^>(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;
        }
        ESimWatcher *wrapper = ESimWatcher::Unwrap<ESimWatcher>(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->Added::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Networking::NetworkOperators::ESimWatcher^, ::Windows::Networking::NetworkOperators::ESimAddedEventArgs^>(
            [callbackObjPtr](::Windows::Networking::NetworkOperators::ESimWatcher^ arg0, ::Windows::Networking::NetworkOperators::ESimAddedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapESimWatcher(arg0);
                  wrappedArg1 = WrapESimAddedEventArgs(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"enumerationCompleted", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimWatcher^>(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;
        }
        ESimWatcher *wrapper = ESimWatcher::Unwrap<ESimWatcher>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->EnumerationCompleted::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Networking::NetworkOperators::ESimWatcher^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Networking::NetworkOperators::ESimWatcher^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapESimWatcher(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"removed", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimWatcher^>(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;
        }
        ESimWatcher *wrapper = ESimWatcher::Unwrap<ESimWatcher>(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->Removed::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Networking::NetworkOperators::ESimWatcher^, ::Windows::Networking::NetworkOperators::ESimRemovedEventArgs^>(
            [callbackObjPtr](::Windows::Networking::NetworkOperators::ESimWatcher^ arg0, ::Windows::Networking::NetworkOperators::ESimRemovedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapESimWatcher(arg0);
                  wrappedArg1 = WrapESimRemovedEventArgs(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"stopped", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimWatcher^>(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;
        }
        ESimWatcher *wrapper = ESimWatcher::Unwrap<ESimWatcher>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->Stopped::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Networking::NetworkOperators::ESimWatcher^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Networking::NetworkOperators::ESimWatcher^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapESimWatcher(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"updated", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimWatcher^>(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;
        }
        ESimWatcher *wrapper = ESimWatcher::Unwrap<ESimWatcher>(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->Updated::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Networking::NetworkOperators::ESimWatcher^, ::Windows::Networking::NetworkOperators::ESimUpdatedEventArgs^>(
            [callbackObjPtr](::Windows::Networking::NetworkOperators::ESimWatcher^ arg0, ::Windows::Networking::NetworkOperators::ESimUpdatedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapESimWatcher(arg0);
                  wrappedArg1 = WrapESimUpdatedEventArgs(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"added", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"enumerationCompleted", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"removed", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"stopped", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"updated", 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"added", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimWatcher^>(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;
          }
          ESimWatcher *wrapper = ESimWatcher::Unwrap<ESimWatcher>(info.This());
          wrapper->_instance->Added::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"enumerationCompleted", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimWatcher^>(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;
          }
          ESimWatcher *wrapper = ESimWatcher::Unwrap<ESimWatcher>(info.This());
          wrapper->_instance->EnumerationCompleted::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"removed", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimWatcher^>(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;
          }
          ESimWatcher *wrapper = ESimWatcher::Unwrap<ESimWatcher>(info.This());
          wrapper->_instance->Removed::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"stopped", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimWatcher^>(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;
          }
          ESimWatcher *wrapper = ESimWatcher::Unwrap<ESimWatcher>(info.This());
          wrapper->_instance->Stopped::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"updated", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimWatcher^>(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;
          }
          ESimWatcher *wrapper = ESimWatcher::Unwrap<ESimWatcher>(info.This());
          wrapper->_instance->Updated::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::NetworkOperators::ESimWatcher^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapESimWatcher(::Windows::Networking::NetworkOperators::ESimWatcher^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::ESimWatcher^ UnwrapESimWatcher(Local<Value> value);
  };

  Persistent<FunctionTemplate> ESimWatcher::s_constructorTemplate;

  v8::Local<v8::Value> WrapESimWatcher(::Windows::Networking::NetworkOperators::ESimWatcher^ 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>(ESimWatcher::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::ESimWatcher^ UnwrapESimWatcher(Local<Value> value) {
     return ESimWatcher::Unwrap<ESimWatcher>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitESimWatcher(Local<Object> exports) {
    ESimWatcher::Init(exports);
  }

  class ESimManager : 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>("ESimManager").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);






        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetMethod(constructor, "tryCreateESimWatcher", TryCreateESimWatcher);
        Nan::SetAccessor(constructor, Nan::New<String>("serviceInfo").ToLocalChecked(), ServiceInfoGetter);
        
              Local<Function> addListenerFunc = Nan::GetFunction(Nan::New<FunctionTemplate>(AddListener)).ToLocalChecked();
              Nan::Set(constructor, Nan::New<String>("addListener").ToLocalChecked(), addListenerFunc);
              Nan::Set(constructor, Nan::New<String>("on").ToLocalChecked(), addListenerFunc);
              Local<Function> removeListenerFunc = Nan::GetFunction(Nan::New<FunctionTemplate>(RemoveListener)).ToLocalChecked();
              Nan::Set(constructor, Nan::New<String>("removeListener").ToLocalChecked(), removeListenerFunc);
              Nan::Set(constructor, Nan::New<String>("off").ToLocalChecked(), removeListenerFunc);


        Nan::Set(exports, Nan::New<String>("ESimManager").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ESimManager(::Windows::Networking::NetworkOperators::ESimManager^ 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::NetworkOperators::ESimManager^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimManager^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::ESimManager^) 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());

      ESimManager *wrapperInstance = new ESimManager(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::NetworkOperators::ESimManager^>(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::NetworkOperators::ESimManager^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::ESimManager^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapESimManager(winRtInstance));
    }





    static void TryCreateESimWatcher(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Networking::NetworkOperators::ESimWatcher^ result;
          result = ::Windows::Networking::NetworkOperators::ESimManager::TryCreateESimWatcher();
          info.GetReturnValue().Set(WrapESimWatcher(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 ServiceInfoGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::Networking::NetworkOperators::ESimServiceInfo^ result = ::Windows::Networking::NetworkOperators::ESimManager::ServiceInfo;
        info.GetReturnValue().Set(WrapESimServiceInfo(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"serviceInfoChanged", str))
      {
      
        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 = ::Windows::Networking::NetworkOperators::ESimManager::ServiceInfoChanged::add(
            ref new ::Windows::Foundation::EventHandler<::Platform::Object^>(
            [callbackObjPtr](::Platform::Object^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = CreateOpaqueWrapper(arg0);
                  wrappedArg1 = CreateOpaqueWrapper(arg1);


                  if (wrappedArg0.IsEmpty()) wrappedArg0 = Undefined();
                  if (wrappedArg1.IsEmpty()) wrappedArg1 = Undefined();
                }

                Local<Value> args[] = { wrappedArg0, wrappedArg1 };
                Local<Object> callbackObjLocalRef = Nan::New<Object>(*callbackObjPtr);
                NodeRT::Utils::CallCallbackInDomain(callbackObjLocalRef, _countof(args), args);
              });
            })
          );
        }
        catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }

      }
 else  {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

      Local<Value> tokenMapVal = NodeRT::Utils::GetHiddenValue(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked());
      Local<Object> tokenMap;

      if (tokenMapVal.IsEmpty() || Nan::Equals(tokenMapVal, Undefined()).FromMaybe(false)) {
        tokenMap = Nan::New<Object>();
        NodeRT::Utils::SetHiddenValueWithObject(callback, Nan::New<String>(REGISTRATION_TOKEN_MAP_PROPERTY_NAME).ToLocalChecked(), tokenMap);
      } else {
        tokenMap = Nan::To<Object>(tokenMapVal).ToLocalChecked();
      }

      Nan::Set(tokenMap, info[0], CreateOpaqueWrapper(::Windows::Foundation::PropertyValue::CreateInt64(registrationToken.Value)));
    }

    static void RemoveListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected a string and a callback")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      if ((!NodeRT::Utils::CaseInsenstiveEquals(L"serviceInfoChanged", 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"serviceInfoChanged", str)) {
          ::Windows::Networking::NetworkOperators::ESimManager::ServiceInfoChanged::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::NetworkOperators::ESimManager^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapESimManager(::Windows::Networking::NetworkOperators::ESimManager^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::ESimManager^ UnwrapESimManager(Local<Value> value);
  };

  Persistent<FunctionTemplate> ESimManager::s_constructorTemplate;

  v8::Local<v8::Value> WrapESimManager(::Windows::Networking::NetworkOperators::ESimManager^ 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>(ESimManager::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::ESimManager^ UnwrapESimManager(Local<Value> value) {
     return ESimManager::Unwrap<ESimManager>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitESimManager(Local<Object> exports) {
    ESimManager::Init(exports);
  }

  class ESimProfilePolicy : 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>("ESimProfilePolicy").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("canDelete").ToLocalChecked(), CanDeleteGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("canDisable").ToLocalChecked(), CanDisableGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isManagedByEnterprise").ToLocalChecked(), IsManagedByEnterpriseGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ESimProfilePolicy").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ESimProfilePolicy(::Windows::Networking::NetworkOperators::ESimProfilePolicy^ 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::NetworkOperators::ESimProfilePolicy^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfilePolicy^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::ESimProfilePolicy^) 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());

      ESimProfilePolicy *wrapperInstance = new ESimProfilePolicy(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::NetworkOperators::ESimProfilePolicy^>(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::NetworkOperators::ESimProfilePolicy^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::ESimProfilePolicy^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapESimProfilePolicy(winRtInstance));
    }





    static void CanDeleteGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfilePolicy^>(info.This())) {
        return;
      }

      ESimProfilePolicy *wrapper = ESimProfilePolicy::Unwrap<ESimProfilePolicy>(info.This());

      try  {
        bool result = wrapper->_instance->CanDelete;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CanDisableGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfilePolicy^>(info.This())) {
        return;
      }

      ESimProfilePolicy *wrapper = ESimProfilePolicy::Unwrap<ESimProfilePolicy>(info.This());

      try  {
        bool result = wrapper->_instance->CanDisable;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsManagedByEnterpriseGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimProfilePolicy^>(info.This())) {
        return;
      }

      ESimProfilePolicy *wrapper = ESimProfilePolicy::Unwrap<ESimProfilePolicy>(info.This());

      try  {
        bool result = wrapper->_instance->IsManagedByEnterprise;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::ESimProfilePolicy^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapESimProfilePolicy(::Windows::Networking::NetworkOperators::ESimProfilePolicy^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::ESimProfilePolicy^ UnwrapESimProfilePolicy(Local<Value> value);
  };

  Persistent<FunctionTemplate> ESimProfilePolicy::s_constructorTemplate;

  v8::Local<v8::Value> WrapESimProfilePolicy(::Windows::Networking::NetworkOperators::ESimProfilePolicy^ 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>(ESimProfilePolicy::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::ESimProfilePolicy^ UnwrapESimProfilePolicy(Local<Value> value) {
     return ESimProfilePolicy::Unwrap<ESimProfilePolicy>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitESimProfilePolicy(Local<Object> exports) {
    ESimProfilePolicy::Init(exports);
  }

  class ESimRemovedEventArgs : 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>("ESimRemovedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("eSim").ToLocalChecked(), ESimGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ESimRemovedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ESimRemovedEventArgs(::Windows::Networking::NetworkOperators::ESimRemovedEventArgs^ 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::NetworkOperators::ESimRemovedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimRemovedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::ESimRemovedEventArgs^) 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());

      ESimRemovedEventArgs *wrapperInstance = new ESimRemovedEventArgs(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::NetworkOperators::ESimRemovedEventArgs^>(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::NetworkOperators::ESimRemovedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::ESimRemovedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapESimRemovedEventArgs(winRtInstance));
    }





    static void ESimGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimRemovedEventArgs^>(info.This())) {
        return;
      }

      ESimRemovedEventArgs *wrapper = ESimRemovedEventArgs::Unwrap<ESimRemovedEventArgs>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::ESim^ result = wrapper->_instance->ESim;
        info.GetReturnValue().Set(WrapESim(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::ESimRemovedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapESimRemovedEventArgs(::Windows::Networking::NetworkOperators::ESimRemovedEventArgs^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::ESimRemovedEventArgs^ UnwrapESimRemovedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> ESimRemovedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapESimRemovedEventArgs(::Windows::Networking::NetworkOperators::ESimRemovedEventArgs^ 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>(ESimRemovedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::ESimRemovedEventArgs^ UnwrapESimRemovedEventArgs(Local<Value> value) {
     return ESimRemovedEventArgs::Unwrap<ESimRemovedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitESimRemovedEventArgs(Local<Object> exports) {
    ESimRemovedEventArgs::Init(exports);
  }

  class ESimUpdatedEventArgs : 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>("ESimUpdatedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("eSim").ToLocalChecked(), ESimGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ESimUpdatedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ESimUpdatedEventArgs(::Windows::Networking::NetworkOperators::ESimUpdatedEventArgs^ 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::NetworkOperators::ESimUpdatedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimUpdatedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::ESimUpdatedEventArgs^) 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());

      ESimUpdatedEventArgs *wrapperInstance = new ESimUpdatedEventArgs(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::NetworkOperators::ESimUpdatedEventArgs^>(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::NetworkOperators::ESimUpdatedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::ESimUpdatedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapESimUpdatedEventArgs(winRtInstance));
    }





    static void ESimGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ESimUpdatedEventArgs^>(info.This())) {
        return;
      }

      ESimUpdatedEventArgs *wrapper = ESimUpdatedEventArgs::Unwrap<ESimUpdatedEventArgs>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::ESim^ result = wrapper->_instance->ESim;
        info.GetReturnValue().Set(WrapESim(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::ESimUpdatedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapESimUpdatedEventArgs(::Windows::Networking::NetworkOperators::ESimUpdatedEventArgs^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::ESimUpdatedEventArgs^ UnwrapESimUpdatedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> ESimUpdatedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapESimUpdatedEventArgs(::Windows::Networking::NetworkOperators::ESimUpdatedEventArgs^ 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>(ESimUpdatedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::ESimUpdatedEventArgs^ UnwrapESimUpdatedEventArgs(Local<Value> value) {
     return ESimUpdatedEventArgs::Unwrap<ESimUpdatedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitESimUpdatedEventArgs(Local<Object> exports) {
    ESimUpdatedEventArgs::Init(exports);
  }

  class HotspotAuthenticationEventDetails : 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>("HotspotAuthenticationEventDetails").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("eventToken").ToLocalChecked(), EventTokenGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("HotspotAuthenticationEventDetails").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      HotspotAuthenticationEventDetails(::Windows::Networking::NetworkOperators::HotspotAuthenticationEventDetails^ 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::NetworkOperators::HotspotAuthenticationEventDetails^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::HotspotAuthenticationEventDetails^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::HotspotAuthenticationEventDetails^) 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());

      HotspotAuthenticationEventDetails *wrapperInstance = new HotspotAuthenticationEventDetails(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::NetworkOperators::HotspotAuthenticationEventDetails^>(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::NetworkOperators::HotspotAuthenticationEventDetails^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::HotspotAuthenticationEventDetails^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapHotspotAuthenticationEventDetails(winRtInstance));
    }





    static void EventTokenGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::HotspotAuthenticationEventDetails^>(info.This())) {
        return;
      }

      HotspotAuthenticationEventDetails *wrapper = HotspotAuthenticationEventDetails::Unwrap<HotspotAuthenticationEventDetails>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->EventToken;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::HotspotAuthenticationEventDetails^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapHotspotAuthenticationEventDetails(::Windows::Networking::NetworkOperators::HotspotAuthenticationEventDetails^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::HotspotAuthenticationEventDetails^ UnwrapHotspotAuthenticationEventDetails(Local<Value> value);
  };

  Persistent<FunctionTemplate> HotspotAuthenticationEventDetails::s_constructorTemplate;

  v8::Local<v8::Value> WrapHotspotAuthenticationEventDetails(::Windows::Networking::NetworkOperators::HotspotAuthenticationEventDetails^ 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>(HotspotAuthenticationEventDetails::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::HotspotAuthenticationEventDetails^ UnwrapHotspotAuthenticationEventDetails(Local<Value> value) {
     return HotspotAuthenticationEventDetails::Unwrap<HotspotAuthenticationEventDetails>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitHotspotAuthenticationEventDetails(Local<Object> exports) {
    HotspotAuthenticationEventDetails::Init(exports);
  }

  class HotspotAuthenticationContext : 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>("HotspotAuthenticationContext").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);

        Local<Function> func;
        Local<FunctionTemplate> funcTemplate;

          
            Nan::SetPrototypeMethod(localRef, "issueCredentials", IssueCredentials);
            Nan::SetPrototypeMethod(localRef, "abortAuthentication", AbortAuthentication);
            Nan::SetPrototypeMethod(localRef, "skipAuthentication", SkipAuthentication);
            Nan::SetPrototypeMethod(localRef, "triggerAttentionRequired", TriggerAttentionRequired);
          

          
            Nan::SetPrototypeMethod(localRef, "issueCredentialsAsync", IssueCredentialsAsync);
          


          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("authenticationUrl").ToLocalChecked(), AuthenticationUrlGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("networkAdapter").ToLocalChecked(), NetworkAdapterGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("redirectMessageUrl").ToLocalChecked(), RedirectMessageUrlGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("redirectMessageXml").ToLocalChecked(), RedirectMessageXmlGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("wirelessNetworkId").ToLocalChecked(), WirelessNetworkIdGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetMethod(constructor, "tryGetAuthenticationContext", TryGetAuthenticationContext);


        Nan::Set(exports, Nan::New<String>("HotspotAuthenticationContext").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      HotspotAuthenticationContext(::Windows::Networking::NetworkOperators::HotspotAuthenticationContext^ 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::NetworkOperators::HotspotAuthenticationContext^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::HotspotAuthenticationContext^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::HotspotAuthenticationContext^) 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());

      HotspotAuthenticationContext *wrapperInstance = new HotspotAuthenticationContext(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::NetworkOperators::HotspotAuthenticationContext^>(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::NetworkOperators::HotspotAuthenticationContext^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::HotspotAuthenticationContext^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapHotspotAuthenticationContext(winRtInstance));
    }

    static void IssueCredentialsAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::HotspotAuthenticationContext^>(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;
      }

      HotspotAuthenticationContext *wrapper = HotspotAuthenticationContext::Unwrap<HotspotAuthenticationContext>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::NetworkOperators::HotspotCredentialsAuthenticationResult^>^ op;


      if (info.Length() == 5
        && info[0]->IsString()
        && info[1]->IsString()
        && info[2]->IsString()
        && info[3]->IsBoolean())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          Platform::String^ arg2 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[2])));
          bool arg3 = Nan::To<bool>(info[3]).FromMaybe(false);
          
          op = wrapper->_instance->IssueCredentialsAsync(arg0,arg1,arg2,arg3);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

      auto opTask = create_task(op);
      uv_async_t* asyncToken = NodeUtils::Async::GetAsyncToken(info[info.Length() -1].As<Function>());

      opTask.then( [asyncToken] (task<::Windows::Networking::NetworkOperators::HotspotCredentialsAuthenticationResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapHotspotCredentialsAuthenticationResult(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 IssueCredentials(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::HotspotAuthenticationContext^>(info.This())) {
        return;
      }

      HotspotAuthenticationContext *wrapper = HotspotAuthenticationContext::Unwrap<HotspotAuthenticationContext>(info.This());

      if (info.Length() == 4
        && info[0]->IsString()
        && info[1]->IsString()
        && info[2]->IsString()
        && info[3]->IsBoolean())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          Platform::String^ arg2 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[2])));
          bool arg3 = Nan::To<bool>(info[3]).FromMaybe(false);
          
          wrapper->_instance->IssueCredentials(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;
      }
    }
    static void AbortAuthentication(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::HotspotAuthenticationContext^>(info.This())) {
        return;
      }

      HotspotAuthenticationContext *wrapper = HotspotAuthenticationContext::Unwrap<HotspotAuthenticationContext>(info.This());

      if (info.Length() == 1
        && info[0]->IsBoolean())
      {
        try
        {
          bool arg0 = Nan::To<bool>(info[0]).FromMaybe(false);
          
          wrapper->_instance->AbortAuthentication(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 SkipAuthentication(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::HotspotAuthenticationContext^>(info.This())) {
        return;
      }

      HotspotAuthenticationContext *wrapper = HotspotAuthenticationContext::Unwrap<HotspotAuthenticationContext>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->SkipAuthentication();
          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 TriggerAttentionRequired(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::HotspotAuthenticationContext^>(info.This())) {
        return;
      }

      HotspotAuthenticationContext *wrapper = HotspotAuthenticationContext::Unwrap<HotspotAuthenticationContext>(info.This());

      if (info.Length() == 2
        && info[0]->IsString()
        && info[1]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          
          wrapper->_instance->TriggerAttentionRequired(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 TryGetAuthenticationContext(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Networking::NetworkOperators::HotspotAuthenticationContext^ arg1;  
          
          bool result;
          result = ::Windows::Networking::NetworkOperators::HotspotAuthenticationContext::TryGetAuthenticationContext(arg0, &arg1);
          Local<Object> resObj = Nan::New<Object>();
          Nan::Set(resObj, Nan::New<String>("boolean").ToLocalChecked(), Nan::New<Boolean>(result));
          Nan::Set(resObj, Nan::New<String>("context").ToLocalChecked(), NodeRT::Utils::CreateExternalWinRTObject("Windows.Networking.NetworkOperators", "HotspotAuthenticationContext", 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 AuthenticationUrlGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::HotspotAuthenticationContext^>(info.This())) {
        return;
      }

      HotspotAuthenticationContext *wrapper = HotspotAuthenticationContext::Unwrap<HotspotAuthenticationContext>(info.This());

      try  {
        ::Windows::Foundation::Uri^ result = wrapper->_instance->AuthenticationUrl;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "Uri", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void NetworkAdapterGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::HotspotAuthenticationContext^>(info.This())) {
        return;
      }

      HotspotAuthenticationContext *wrapper = HotspotAuthenticationContext::Unwrap<HotspotAuthenticationContext>(info.This());

      try  {
        ::Windows::Networking::Connectivity::NetworkAdapter^ result = wrapper->_instance->NetworkAdapter;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Networking.Connectivity", "NetworkAdapter", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RedirectMessageUrlGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::HotspotAuthenticationContext^>(info.This())) {
        return;
      }

      HotspotAuthenticationContext *wrapper = HotspotAuthenticationContext::Unwrap<HotspotAuthenticationContext>(info.This());

      try  {
        ::Windows::Foundation::Uri^ result = wrapper->_instance->RedirectMessageUrl;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "Uri", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RedirectMessageXmlGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::HotspotAuthenticationContext^>(info.This())) {
        return;
      }

      HotspotAuthenticationContext *wrapper = HotspotAuthenticationContext::Unwrap<HotspotAuthenticationContext>(info.This());

      try  {
        ::Windows::Data::Xml::Dom::XmlDocument^ result = wrapper->_instance->RedirectMessageXml;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Data.Xml.Dom", "XmlDocument", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void WirelessNetworkIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::HotspotAuthenticationContext^>(info.This())) {
        return;
      }

      HotspotAuthenticationContext *wrapper = HotspotAuthenticationContext::Unwrap<HotspotAuthenticationContext>(info.This());

      try  {
        ::Platform::Array<unsigned char>^ result = wrapper->_instance->WirelessNetworkId;
        info.GetReturnValue().Set(NodeRT::Collections::ArrayWrapper<unsigned char>::CreateArrayWrapper(result, 
            [](unsigned char val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsInt32();
            },
            [](Local<Value> value) -> unsigned char {
              return static_cast<unsigned char>(Nan::To<int32_t>(value).FromMaybe(0));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::HotspotAuthenticationContext^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapHotspotAuthenticationContext(::Windows::Networking::NetworkOperators::HotspotAuthenticationContext^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::HotspotAuthenticationContext^ UnwrapHotspotAuthenticationContext(Local<Value> value);
  };

  Persistent<FunctionTemplate> HotspotAuthenticationContext::s_constructorTemplate;

  v8::Local<v8::Value> WrapHotspotAuthenticationContext(::Windows::Networking::NetworkOperators::HotspotAuthenticationContext^ 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>(HotspotAuthenticationContext::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::HotspotAuthenticationContext^ UnwrapHotspotAuthenticationContext(Local<Value> value) {
     return HotspotAuthenticationContext::Unwrap<HotspotAuthenticationContext>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitHotspotAuthenticationContext(Local<Object> exports) {
    HotspotAuthenticationContext::Init(exports);
  }

  class HotspotCredentialsAuthenticationResult : 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>("HotspotCredentialsAuthenticationResult").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("authenticationReplyXml").ToLocalChecked(), AuthenticationReplyXmlGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("hasNetworkErrorOccurred").ToLocalChecked(), HasNetworkErrorOccurredGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("logoffUrl").ToLocalChecked(), LogoffUrlGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("responseCode").ToLocalChecked(), ResponseCodeGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("HotspotCredentialsAuthenticationResult").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      HotspotCredentialsAuthenticationResult(::Windows::Networking::NetworkOperators::HotspotCredentialsAuthenticationResult^ 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::NetworkOperators::HotspotCredentialsAuthenticationResult^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::HotspotCredentialsAuthenticationResult^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::HotspotCredentialsAuthenticationResult^) 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());

      HotspotCredentialsAuthenticationResult *wrapperInstance = new HotspotCredentialsAuthenticationResult(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::NetworkOperators::HotspotCredentialsAuthenticationResult^>(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::NetworkOperators::HotspotCredentialsAuthenticationResult^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::HotspotCredentialsAuthenticationResult^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapHotspotCredentialsAuthenticationResult(winRtInstance));
    }





    static void AuthenticationReplyXmlGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::HotspotCredentialsAuthenticationResult^>(info.This())) {
        return;
      }

      HotspotCredentialsAuthenticationResult *wrapper = HotspotCredentialsAuthenticationResult::Unwrap<HotspotCredentialsAuthenticationResult>(info.This());

      try  {
        ::Windows::Data::Xml::Dom::XmlDocument^ result = wrapper->_instance->AuthenticationReplyXml;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Data.Xml.Dom", "XmlDocument", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void HasNetworkErrorOccurredGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::HotspotCredentialsAuthenticationResult^>(info.This())) {
        return;
      }

      HotspotCredentialsAuthenticationResult *wrapper = HotspotCredentialsAuthenticationResult::Unwrap<HotspotCredentialsAuthenticationResult>(info.This());

      try  {
        bool result = wrapper->_instance->HasNetworkErrorOccurred;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void LogoffUrlGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::HotspotCredentialsAuthenticationResult^>(info.This())) {
        return;
      }

      HotspotCredentialsAuthenticationResult *wrapper = HotspotCredentialsAuthenticationResult::Unwrap<HotspotCredentialsAuthenticationResult>(info.This());

      try  {
        ::Windows::Foundation::Uri^ result = wrapper->_instance->LogoffUrl;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "Uri", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ResponseCodeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::HotspotCredentialsAuthenticationResult^>(info.This())) {
        return;
      }

      HotspotCredentialsAuthenticationResult *wrapper = HotspotCredentialsAuthenticationResult::Unwrap<HotspotCredentialsAuthenticationResult>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::HotspotAuthenticationResponseCode result = wrapper->_instance->ResponseCode;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::HotspotCredentialsAuthenticationResult^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapHotspotCredentialsAuthenticationResult(::Windows::Networking::NetworkOperators::HotspotCredentialsAuthenticationResult^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::HotspotCredentialsAuthenticationResult^ UnwrapHotspotCredentialsAuthenticationResult(Local<Value> value);
  };

  Persistent<FunctionTemplate> HotspotCredentialsAuthenticationResult::s_constructorTemplate;

  v8::Local<v8::Value> WrapHotspotCredentialsAuthenticationResult(::Windows::Networking::NetworkOperators::HotspotCredentialsAuthenticationResult^ 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>(HotspotCredentialsAuthenticationResult::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::HotspotCredentialsAuthenticationResult^ UnwrapHotspotCredentialsAuthenticationResult(Local<Value> value) {
     return HotspotCredentialsAuthenticationResult::Unwrap<HotspotCredentialsAuthenticationResult>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitHotspotCredentialsAuthenticationResult(Local<Object> exports) {
    HotspotCredentialsAuthenticationResult::Init(exports);
  }

  class ProvisionFromXmlDocumentResults : 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>("ProvisionFromXmlDocumentResults").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("allElementsProvisioned").ToLocalChecked(), AllElementsProvisionedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("provisionResultsXml").ToLocalChecked(), ProvisionResultsXmlGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ProvisionFromXmlDocumentResults").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ProvisionFromXmlDocumentResults(::Windows::Networking::NetworkOperators::ProvisionFromXmlDocumentResults^ 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::NetworkOperators::ProvisionFromXmlDocumentResults^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ProvisionFromXmlDocumentResults^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::ProvisionFromXmlDocumentResults^) 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());

      ProvisionFromXmlDocumentResults *wrapperInstance = new ProvisionFromXmlDocumentResults(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::NetworkOperators::ProvisionFromXmlDocumentResults^>(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::NetworkOperators::ProvisionFromXmlDocumentResults^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::ProvisionFromXmlDocumentResults^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapProvisionFromXmlDocumentResults(winRtInstance));
    }





    static void AllElementsProvisionedGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ProvisionFromXmlDocumentResults^>(info.This())) {
        return;
      }

      ProvisionFromXmlDocumentResults *wrapper = ProvisionFromXmlDocumentResults::Unwrap<ProvisionFromXmlDocumentResults>(info.This());

      try  {
        bool result = wrapper->_instance->AllElementsProvisioned;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ProvisionResultsXmlGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ProvisionFromXmlDocumentResults^>(info.This())) {
        return;
      }

      ProvisionFromXmlDocumentResults *wrapper = ProvisionFromXmlDocumentResults::Unwrap<ProvisionFromXmlDocumentResults>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->ProvisionResultsXml;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::ProvisionFromXmlDocumentResults^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapProvisionFromXmlDocumentResults(::Windows::Networking::NetworkOperators::ProvisionFromXmlDocumentResults^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::ProvisionFromXmlDocumentResults^ UnwrapProvisionFromXmlDocumentResults(Local<Value> value);
  };

  Persistent<FunctionTemplate> ProvisionFromXmlDocumentResults::s_constructorTemplate;

  v8::Local<v8::Value> WrapProvisionFromXmlDocumentResults(::Windows::Networking::NetworkOperators::ProvisionFromXmlDocumentResults^ 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>(ProvisionFromXmlDocumentResults::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::ProvisionFromXmlDocumentResults^ UnwrapProvisionFromXmlDocumentResults(Local<Value> value) {
     return ProvisionFromXmlDocumentResults::Unwrap<ProvisionFromXmlDocumentResults>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitProvisionFromXmlDocumentResults(Local<Object> exports) {
    ProvisionFromXmlDocumentResults::Init(exports);
  }

  class ProvisionedProfile : 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>("ProvisionedProfile").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "updateCost", UpdateCost);
            Nan::SetPrototypeMethod(localRef, "updateUsage", UpdateUsage);
          




        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ProvisionedProfile").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ProvisionedProfile(::Windows::Networking::NetworkOperators::ProvisionedProfile^ 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::NetworkOperators::ProvisionedProfile^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ProvisionedProfile^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::ProvisionedProfile^) 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());

      ProvisionedProfile *wrapperInstance = new ProvisionedProfile(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::NetworkOperators::ProvisionedProfile^>(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::NetworkOperators::ProvisionedProfile^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::ProvisionedProfile^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapProvisionedProfile(winRtInstance));
    }


    static void UpdateCost(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ProvisionedProfile^>(info.This())) {
        return;
      }

      ProvisionedProfile *wrapper = ProvisionedProfile::Unwrap<ProvisionedProfile>(info.This());

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::Networking::Connectivity::NetworkCostType arg0 = static_cast<::Windows::Networking::Connectivity::NetworkCostType>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          wrapper->_instance->UpdateCost(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 UpdateUsage(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ProvisionedProfile^>(info.This())) {
        return;
      }

      ProvisionedProfile *wrapper = ProvisionedProfile::Unwrap<ProvisionedProfile>(info.This());

      if (info.Length() == 1
        && IsProfileUsageJsObject(info[0]))
      {
        try
        {
          ::Windows::Networking::NetworkOperators::ProfileUsage arg0 = ProfileUsageFromJsObject(info[0]);
          
          wrapper->_instance->UpdateUsage(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





    private:
      ::Windows::Networking::NetworkOperators::ProvisionedProfile^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapProvisionedProfile(::Windows::Networking::NetworkOperators::ProvisionedProfile^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::ProvisionedProfile^ UnwrapProvisionedProfile(Local<Value> value);
  };

  Persistent<FunctionTemplate> ProvisionedProfile::s_constructorTemplate;

  v8::Local<v8::Value> WrapProvisionedProfile(::Windows::Networking::NetworkOperators::ProvisionedProfile^ 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>(ProvisionedProfile::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::ProvisionedProfile^ UnwrapProvisionedProfile(Local<Value> value) {
     return ProvisionedProfile::Unwrap<ProvisionedProfile>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitProvisionedProfile(Local<Object> exports) {
    ProvisionedProfile::Init(exports);
  }

  class ProvisioningAgent : 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>("ProvisioningAgent").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);

        Local<Function> func;
        Local<FunctionTemplate> funcTemplate;

          
            Nan::SetPrototypeMethod(localRef, "getProvisionedProfile", GetProvisionedProfile);
          

          
            Nan::SetPrototypeMethod(localRef, "provisionFromXmlDocumentAsync", ProvisionFromXmlDocumentAsync);
          



        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetMethod(constructor, "createFromNetworkAccountId", CreateFromNetworkAccountId);


        Nan::Set(exports, Nan::New<String>("ProvisioningAgent").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ProvisioningAgent(::Windows::Networking::NetworkOperators::ProvisioningAgent^ 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::NetworkOperators::ProvisioningAgent^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ProvisioningAgent^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::ProvisioningAgent^) 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::NetworkOperators::ProvisioningAgent();
        } 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());

      ProvisioningAgent *wrapperInstance = new ProvisioningAgent(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::NetworkOperators::ProvisioningAgent^>(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::NetworkOperators::ProvisioningAgent^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::ProvisioningAgent^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapProvisioningAgent(winRtInstance));
    }

    static void ProvisionFromXmlDocumentAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ProvisioningAgent^>(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;
      }

      ProvisioningAgent *wrapper = ProvisioningAgent::Unwrap<ProvisioningAgent>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::NetworkOperators::ProvisionFromXmlDocumentResults^>^ 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->ProvisionFromXmlDocumentAsync(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::NetworkOperators::ProvisionFromXmlDocumentResults^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapProvisionFromXmlDocumentResults(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 GetProvisionedProfile(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::ProvisioningAgent^>(info.This())) {
        return;
      }

      ProvisioningAgent *wrapper = ProvisioningAgent::Unwrap<ProvisioningAgent>(info.This());

      if (info.Length() == 2
        && info[0]->IsInt32()
        && info[1]->IsString())
      {
        try
        {
          ::Windows::Networking::NetworkOperators::ProfileMediaType arg0 = static_cast<::Windows::Networking::NetworkOperators::ProfileMediaType>(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])));
          
          ::Windows::Networking::NetworkOperators::ProvisionedProfile^ result;
          result = wrapper->_instance->GetProvisionedProfile(arg0, arg1);
          info.GetReturnValue().Set(WrapProvisionedProfile(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 CreateFromNetworkAccountId(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          ::Windows::Networking::NetworkOperators::ProvisioningAgent^ result;
          result = ::Windows::Networking::NetworkOperators::ProvisioningAgent::CreateFromNetworkAccountId(arg0);
          info.GetReturnValue().Set(WrapProvisioningAgent(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::NetworkOperators::ProvisioningAgent^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapProvisioningAgent(::Windows::Networking::NetworkOperators::ProvisioningAgent^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::ProvisioningAgent^ UnwrapProvisioningAgent(Local<Value> value);
  };

  Persistent<FunctionTemplate> ProvisioningAgent::s_constructorTemplate;

  v8::Local<v8::Value> WrapProvisioningAgent(::Windows::Networking::NetworkOperators::ProvisioningAgent^ 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>(ProvisioningAgent::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::ProvisioningAgent^ UnwrapProvisioningAgent(Local<Value> value) {
     return ProvisioningAgent::Unwrap<ProvisioningAgent>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitProvisioningAgent(Local<Object> exports) {
    ProvisioningAgent::Init(exports);
  }

  class UssdMessage : 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>("UssdMessage").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "getPayload", GetPayload);
            Nan::SetPrototypeMethod(localRef, "setPayload", SetPayload);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("payloadAsText").ToLocalChecked(), PayloadAsTextGetter, PayloadAsTextSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dataCodingScheme").ToLocalChecked(), DataCodingSchemeGetter, DataCodingSchemeSetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("UssdMessage").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      UssdMessage(::Windows::Networking::NetworkOperators::UssdMessage^ 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::NetworkOperators::UssdMessage^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::UssdMessage^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::UssdMessage^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && info[0]->IsString())
      {
        try {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          winRtInstance = ref new ::Windows::Networking::NetworkOperators::UssdMessage(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());

      UssdMessage *wrapperInstance = new UssdMessage(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::NetworkOperators::UssdMessage^>(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::NetworkOperators::UssdMessage^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::UssdMessage^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapUssdMessage(winRtInstance));
    }


    static void GetPayload(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::UssdMessage^>(info.This())) {
        return;
      }

      UssdMessage *wrapper = UssdMessage::Unwrap<UssdMessage>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Platform::Array<unsigned char>^ result;
          result = wrapper->_instance->GetPayload();
          info.GetReturnValue().Set(NodeRT::Collections::ArrayWrapper<unsigned char>::CreateArrayWrapper(result, 
            [](unsigned char val) -> Local<Value> {
              return Nan::New<Integer>(val);
            },
            [](Local<Value> value) -> bool {
              return value->IsInt32();
            },
            [](Local<Value> value) -> unsigned char {
              return static_cast<unsigned char>(Nan::To<int32_t>(value).FromMaybe(0));
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void SetPayload(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::UssdMessage^>(info.This())) {
        return;
      }

      UssdMessage *wrapper = UssdMessage::Unwrap<UssdMessage>(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]);
          
          wrapper->_instance->SetPayload(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 PayloadAsTextGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::UssdMessage^>(info.This())) {
        return;
      }

      UssdMessage *wrapper = UssdMessage::Unwrap<UssdMessage>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->PayloadAsText;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PayloadAsTextSetter(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::NetworkOperators::UssdMessage^>(info.This())) {
        return;
      }

      UssdMessage *wrapper = UssdMessage::Unwrap<UssdMessage>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->PayloadAsText = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void DataCodingSchemeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::UssdMessage^>(info.This())) {
        return;
      }

      UssdMessage *wrapper = UssdMessage::Unwrap<UssdMessage>(info.This());

      try  {
        unsigned char result = wrapper->_instance->DataCodingScheme;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DataCodingSchemeSetter(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::NetworkOperators::UssdMessage^>(info.This())) {
        return;
      }

      UssdMessage *wrapper = UssdMessage::Unwrap<UssdMessage>(info.This());

      try {

        unsigned char winRtValue = static_cast<unsigned char>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->DataCodingScheme = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::UssdMessage^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapUssdMessage(::Windows::Networking::NetworkOperators::UssdMessage^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::UssdMessage^ UnwrapUssdMessage(Local<Value> value);
  };

  Persistent<FunctionTemplate> UssdMessage::s_constructorTemplate;

  v8::Local<v8::Value> WrapUssdMessage(::Windows::Networking::NetworkOperators::UssdMessage^ 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>(UssdMessage::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::UssdMessage^ UnwrapUssdMessage(Local<Value> value) {
     return UssdMessage::Unwrap<UssdMessage>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitUssdMessage(Local<Object> exports) {
    UssdMessage::Init(exports);
  }

  class UssdReply : 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>("UssdReply").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("message").ToLocalChecked(), MessageGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("resultCode").ToLocalChecked(), ResultCodeGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("UssdReply").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      UssdReply(::Windows::Networking::NetworkOperators::UssdReply^ 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::NetworkOperators::UssdReply^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::UssdReply^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::UssdReply^) 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());

      UssdReply *wrapperInstance = new UssdReply(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::NetworkOperators::UssdReply^>(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::NetworkOperators::UssdReply^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::UssdReply^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapUssdReply(winRtInstance));
    }





    static void MessageGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::UssdReply^>(info.This())) {
        return;
      }

      UssdReply *wrapper = UssdReply::Unwrap<UssdReply>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::UssdMessage^ result = wrapper->_instance->Message;
        info.GetReturnValue().Set(WrapUssdMessage(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ResultCodeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::UssdReply^>(info.This())) {
        return;
      }

      UssdReply *wrapper = UssdReply::Unwrap<UssdReply>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::UssdResultCode result = wrapper->_instance->ResultCode;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::UssdReply^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapUssdReply(::Windows::Networking::NetworkOperators::UssdReply^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::UssdReply^ UnwrapUssdReply(Local<Value> value);
  };

  Persistent<FunctionTemplate> UssdReply::s_constructorTemplate;

  v8::Local<v8::Value> WrapUssdReply(::Windows::Networking::NetworkOperators::UssdReply^ 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>(UssdReply::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::UssdReply^ UnwrapUssdReply(Local<Value> value) {
     return UssdReply::Unwrap<UssdReply>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitUssdReply(Local<Object> exports) {
    UssdReply::Init(exports);
  }

  class UssdSession : 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>("UssdSession").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);

        Local<Function> func;
        Local<FunctionTemplate> funcTemplate;

          
            Nan::SetPrototypeMethod(localRef, "close", Close);
          

          
            Nan::SetPrototypeMethod(localRef, "sendMessageAndGetReplyAsync", SendMessageAndGetReplyAsync);
          



        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetMethod(constructor, "createFromNetworkAccountId", CreateFromNetworkAccountId);
        Nan::SetMethod(constructor, "createFromNetworkInterfaceId", CreateFromNetworkInterfaceId);


        Nan::Set(exports, Nan::New<String>("UssdSession").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      UssdSession(::Windows::Networking::NetworkOperators::UssdSession^ 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::NetworkOperators::UssdSession^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::UssdSession^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::UssdSession^) 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());

      UssdSession *wrapperInstance = new UssdSession(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::NetworkOperators::UssdSession^>(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::NetworkOperators::UssdSession^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::UssdSession^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapUssdSession(winRtInstance));
    }

    static void SendMessageAndGetReplyAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::UssdSession^>(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;
      }

      UssdSession *wrapper = UssdSession::Unwrap<UssdSession>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::Networking::NetworkOperators::UssdReply^>^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::UssdMessage^>(info[0]))
      {
        try
        {
          ::Windows::Networking::NetworkOperators::UssdMessage^ arg0 = UnwrapUssdMessage(info[0]);
          
          op = wrapper->_instance->SendMessageAndGetReplyAsync(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::NetworkOperators::UssdReply^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapUssdReply(result);
              if (tryCatch.HasCaught())
              {
                error = Nan::To<Object>(tryCatch.Exception()).ToLocalChecked();
              }
              else
              {
                error = Undefined();
              }
              if (arg1.IsEmpty()) arg1 = Undefined();
            }
            Local<Value> args[] = {error, arg1};


            invokeCallback(_countof(args), args);
          });
        } catch (Platform::Exception^ exception) {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {
            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

            Local<Value> args[] = {error};
            invokeCallback(_countof(args), args);
          });
        }
      });
    }

    static void Close(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::UssdSession^>(info.This())) {
        return;
      }

      UssdSession *wrapper = UssdSession::Unwrap<UssdSession>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->Close();
          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 CreateFromNetworkAccountId(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          ::Windows::Networking::NetworkOperators::UssdSession^ result;
          result = ::Windows::Networking::NetworkOperators::UssdSession::CreateFromNetworkAccountId(arg0);
          info.GetReturnValue().Set(WrapUssdSession(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 CreateFromNetworkInterfaceId(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          ::Windows::Networking::NetworkOperators::UssdSession^ result;
          result = ::Windows::Networking::NetworkOperators::UssdSession::CreateFromNetworkInterfaceId(arg0);
          info.GetReturnValue().Set(WrapUssdSession(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::NetworkOperators::UssdSession^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapUssdSession(::Windows::Networking::NetworkOperators::UssdSession^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::UssdSession^ UnwrapUssdSession(Local<Value> value);
  };

  Persistent<FunctionTemplate> UssdSession::s_constructorTemplate;

  v8::Local<v8::Value> WrapUssdSession(::Windows::Networking::NetworkOperators::UssdSession^ 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>(UssdSession::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::UssdSession^ UnwrapUssdSession(Local<Value> value) {
     return UssdSession::Unwrap<UssdSession>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitUssdSession(Local<Object> exports) {
    UssdSession::Init(exports);
  }

  class NetworkOperatorNotificationEventDetails : 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>("NetworkOperatorNotificationEventDetails").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "authorizeTethering", AuthorizeTethering);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("encodingType").ToLocalChecked(), EncodingTypeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("message").ToLocalChecked(), MessageGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("networkAccountId").ToLocalChecked(), NetworkAccountIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("notificationType").ToLocalChecked(), NotificationTypeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("ruleId").ToLocalChecked(), RuleIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("smsMessage").ToLocalChecked(), SmsMessageGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("NetworkOperatorNotificationEventDetails").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      NetworkOperatorNotificationEventDetails(::Windows::Networking::NetworkOperators::NetworkOperatorNotificationEventDetails^ 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::NetworkOperators::NetworkOperatorNotificationEventDetails^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::NetworkOperatorNotificationEventDetails^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::NetworkOperatorNotificationEventDetails^) 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());

      NetworkOperatorNotificationEventDetails *wrapperInstance = new NetworkOperatorNotificationEventDetails(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::NetworkOperators::NetworkOperatorNotificationEventDetails^>(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::NetworkOperators::NetworkOperatorNotificationEventDetails^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::NetworkOperatorNotificationEventDetails^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapNetworkOperatorNotificationEventDetails(winRtInstance));
    }


    static void AuthorizeTethering(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::NetworkOperatorNotificationEventDetails^>(info.This())) {
        return;
      }

      NetworkOperatorNotificationEventDetails *wrapper = NetworkOperatorNotificationEventDetails::Unwrap<NetworkOperatorNotificationEventDetails>(info.This());

      if (info.Length() == 2
        && info[0]->IsBoolean()
        && info[1]->IsString())
      {
        try
        {
          bool arg0 = Nan::To<bool>(info[0]).FromMaybe(false);
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          
          wrapper->_instance->AuthorizeTethering(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 EncodingTypeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::NetworkOperatorNotificationEventDetails^>(info.This())) {
        return;
      }

      NetworkOperatorNotificationEventDetails *wrapper = NetworkOperatorNotificationEventDetails::Unwrap<NetworkOperatorNotificationEventDetails>(info.This());

      try  {
        unsigned char result = wrapper->_instance->EncodingType;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MessageGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::NetworkOperatorNotificationEventDetails^>(info.This())) {
        return;
      }

      NetworkOperatorNotificationEventDetails *wrapper = NetworkOperatorNotificationEventDetails::Unwrap<NetworkOperatorNotificationEventDetails>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Message;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void NetworkAccountIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::NetworkOperatorNotificationEventDetails^>(info.This())) {
        return;
      }

      NetworkOperatorNotificationEventDetails *wrapper = NetworkOperatorNotificationEventDetails::Unwrap<NetworkOperatorNotificationEventDetails>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->NetworkAccountId;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void NotificationTypeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::NetworkOperatorNotificationEventDetails^>(info.This())) {
        return;
      }

      NetworkOperatorNotificationEventDetails *wrapper = NetworkOperatorNotificationEventDetails::Unwrap<NetworkOperatorNotificationEventDetails>(info.This());

      try  {
        ::Windows::Networking::NetworkOperators::NetworkOperatorEventMessageType result = wrapper->_instance->NotificationType;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RuleIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::NetworkOperatorNotificationEventDetails^>(info.This())) {
        return;
      }

      NetworkOperatorNotificationEventDetails *wrapper = NetworkOperatorNotificationEventDetails::Unwrap<NetworkOperatorNotificationEventDetails>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->RuleId;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SmsMessageGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::NetworkOperatorNotificationEventDetails^>(info.This())) {
        return;
      }

      NetworkOperatorNotificationEventDetails *wrapper = NetworkOperatorNotificationEventDetails::Unwrap<NetworkOperatorNotificationEventDetails>(info.This());

      try  {
        ::Windows::Devices::Sms::ISmsMessage^ result = wrapper->_instance->SmsMessage;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Devices.Sms", "ISmsMessage", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Networking::NetworkOperators::NetworkOperatorNotificationEventDetails^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapNetworkOperatorNotificationEventDetails(::Windows::Networking::NetworkOperators::NetworkOperatorNotificationEventDetails^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::NetworkOperatorNotificationEventDetails^ UnwrapNetworkOperatorNotificationEventDetails(Local<Value> value);
  };

  Persistent<FunctionTemplate> NetworkOperatorNotificationEventDetails::s_constructorTemplate;

  v8::Local<v8::Value> WrapNetworkOperatorNotificationEventDetails(::Windows::Networking::NetworkOperators::NetworkOperatorNotificationEventDetails^ 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>(NetworkOperatorNotificationEventDetails::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::NetworkOperatorNotificationEventDetails^ UnwrapNetworkOperatorNotificationEventDetails(Local<Value> value) {
     return NetworkOperatorNotificationEventDetails::Unwrap<NetworkOperatorNotificationEventDetails>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitNetworkOperatorNotificationEventDetails(Local<Object> exports) {
    NetworkOperatorNotificationEventDetails::Init(exports);
  }

  class FdnAccessManager : 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>("FdnAccessManager").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);

        Local<Function> func;
        Local<FunctionTemplate> funcTemplate;





        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        func = Nan::GetFunction(Nan::New<FunctionTemplate>(RequestUnlockAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("requestUnlockAsync").ToLocalChecked(), func);


        Nan::Set(exports, Nan::New<String>("FdnAccessManager").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      FdnAccessManager(::Windows::Networking::NetworkOperators::FdnAccessManager^ 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::NetworkOperators::FdnAccessManager^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Networking::NetworkOperators::FdnAccessManager^>(info[0])) {
        try {
          winRtInstance = (::Windows::Networking::NetworkOperators::FdnAccessManager^) 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());

      FdnAccessManager *wrapperInstance = new FdnAccessManager(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::NetworkOperators::FdnAccessManager^>(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::NetworkOperators::FdnAccessManager^ winRtInstance;
      try {
        winRtInstance = (::Windows::Networking::NetworkOperators::FdnAccessManager^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapFdnAccessManager(winRtInstance));
    }




    static void RequestUnlockAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0 || !info[info.Length() -1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: No callback was given")));
        return;
      }

      ::Windows::Foundation::IAsyncOperation<bool>^ op;


      if (info.Length() == 2
          && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
            
          op = ::Windows::Networking::NetworkOperators::FdnAccessManager::RequestUnlockAsync(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<bool> 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<Boolean>(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::NetworkOperators::FdnAccessManager^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapFdnAccessManager(::Windows::Networking::NetworkOperators::FdnAccessManager^ wintRtInstance);
      friend ::Windows::Networking::NetworkOperators::FdnAccessManager^ UnwrapFdnAccessManager(Local<Value> value);
  };

  Persistent<FunctionTemplate> FdnAccessManager::s_constructorTemplate;

  v8::Local<v8::Value> WrapFdnAccessManager(::Windows::Networking::NetworkOperators::FdnAccessManager^ 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>(FdnAccessManager::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Networking::NetworkOperators::FdnAccessManager^ UnwrapFdnAccessManager(Local<Value> value) {
     return FdnAccessManager::Unwrap<FdnAccessManager>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitFdnAccessManager(Local<Object> exports) {
    FdnAccessManager::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::NetworkOperators::InitDataClassesEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandDeviceTypeEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitNetworkDeviceStatusEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitNetworkRegistrationStateEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandRadioStateEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitNetworkOperatorDataUsageNotificationKindEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitNetworkOperatorEventMessageTypeEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandAccountWatcherStatusEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitTetheringOperationalStateEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitTetheringCapabilityEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitTetheringOperationStatusEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandPinLockStateEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandPinTypeEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandPinFormatEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandUiccAppOperationStatusEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitUiccAppKindEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitUiccAppRecordKindEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitUiccAccessConditionEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandModemStatusEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitESimAuthenticationPreferenceEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitESimProfileClassEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitESimOperationStatusEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitESimProfileMetadataStateEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitESimProfileStateEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitESimStateEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitESimWatcherStatusEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitHotspotAuthenticationResponseCodeEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitProfileMediaTypeEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitUssdResultCodeEnum(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandAccount(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandNetwork(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandDeviceInformation(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandPinManager(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandUiccApp(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandCellsInfo(target);
      NodeRT::Windows::Networking::NetworkOperators::InitNetworkOperatorDataUsageTriggerDetails(target);
      NodeRT::Windows::Networking::NetworkOperators::InitTetheringEntitlementCheckTriggerDetails(target);
      NodeRT::Windows::Networking::NetworkOperators::InitNetworkOperatorTetheringAccessPointConfiguration(target);
      NodeRT::Windows::Networking::NetworkOperators::InitNetworkOperatorTetheringOperationResult(target);
      NodeRT::Windows::Networking::NetworkOperators::InitNetworkOperatorTetheringManager(target);
      NodeRT::Windows::Networking::NetworkOperators::InitNetworkOperatorTetheringClient(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandAccountEventArgs(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandAccountUpdatedEventArgs(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandAccountWatcher(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandModem(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandUicc(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandSarManager(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandModemConfiguration(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandDeviceServiceInformation(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandDeviceService(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandPco(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandPin(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandPinOperationResult(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandDeviceServiceDataSession(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandDeviceServiceCommandSession(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandDeviceServiceDataReceivedEventArgs(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandDeviceServiceCommandResult(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandUiccAppsResult(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandUiccAppRecordDetailsResult(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandUiccAppReadRecordResult(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandNetworkRegistrationStateChange(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandNetworkRegistrationStateChangeTriggerDetails(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandRadioStateChange(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandRadioStateChangeTriggerDetails(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandPinLockStateChange(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandPinLockStateChangeTriggerDetails(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandDeviceServiceTriggerDetails(target);
      NodeRT::Windows::Networking::NetworkOperators::InitKnownCSimFilePaths(target);
      NodeRT::Windows::Networking::NetworkOperators::InitKnownRuimFilePaths(target);
      NodeRT::Windows::Networking::NetworkOperators::InitKnownSimFilePaths(target);
      NodeRT::Windows::Networking::NetworkOperators::InitKnownUSimFilePaths(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandCellCdma(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandCellGsm(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandCellLte(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandCellTdscdma(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandCellUmts(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandModemIsolation(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandPcoDataChangeTriggerDetails(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandAntennaSar(target);
      NodeRT::Windows::Networking::NetworkOperators::InitMobileBroadbandTransmissionStateChangedEventArgs(target);
      NodeRT::Windows::Networking::NetworkOperators::InitESimPolicy(target);
      NodeRT::Windows::Networking::NetworkOperators::InitESimProfile(target);
      NodeRT::Windows::Networking::NetworkOperators::InitESimOperationResult(target);
      NodeRT::Windows::Networking::NetworkOperators::InitESimDownloadProfileMetadataResult(target);
      NodeRT::Windows::Networking::NetworkOperators::InitESim(target);
      NodeRT::Windows::Networking::NetworkOperators::InitESimAddedEventArgs(target);
      NodeRT::Windows::Networking::NetworkOperators::InitESimProfileMetadata(target);
      NodeRT::Windows::Networking::NetworkOperators::InitESimServiceInfo(target);
      NodeRT::Windows::Networking::NetworkOperators::InitESimWatcher(target);
      NodeRT::Windows::Networking::NetworkOperators::InitESimManager(target);
      NodeRT::Windows::Networking::NetworkOperators::InitESimProfilePolicy(target);
      NodeRT::Windows::Networking::NetworkOperators::InitESimRemovedEventArgs(target);
      NodeRT::Windows::Networking::NetworkOperators::InitESimUpdatedEventArgs(target);
      NodeRT::Windows::Networking::NetworkOperators::InitHotspotAuthenticationEventDetails(target);
      NodeRT::Windows::Networking::NetworkOperators::InitHotspotAuthenticationContext(target);
      NodeRT::Windows::Networking::NetworkOperators::InitHotspotCredentialsAuthenticationResult(target);
      NodeRT::Windows::Networking::NetworkOperators::InitProvisionFromXmlDocumentResults(target);
      NodeRT::Windows::Networking::NetworkOperators::InitProvisionedProfile(target);
      NodeRT::Windows::Networking::NetworkOperators::InitProvisioningAgent(target);
      NodeRT::Windows::Networking::NetworkOperators::InitUssdMessage(target);
      NodeRT::Windows::Networking::NetworkOperators::InitUssdReply(target);
      NodeRT::Windows::Networking::NetworkOperators::InitUssdSession(target);
      NodeRT::Windows::Networking::NetworkOperators::InitNetworkOperatorNotificationEventDetails(target);
      NodeRT::Windows::Networking::NetworkOperators::InitFdnAccessManager(target);


  NodeRT::Utils::RegisterNameSpace("Windows.Networking.NetworkOperators", target);
}



NODE_MODULE(binding, init)