// 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 ApplicationModel { namespace Contacts { 
  v8::Local<v8::Value> WrapContact(::Windows::ApplicationModel::Contacts::Contact^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::Contact^ UnwrapContact(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactCardDelayedDataLoader(::Windows::ApplicationModel::Contacts::ContactCardDelayedDataLoader^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactCardDelayedDataLoader^ UnwrapContactCardDelayedDataLoader(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactStore(::Windows::ApplicationModel::Contacts::ContactStore^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactStore^ UnwrapContactStore(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactAnnotationStore(::Windows::ApplicationModel::Contacts::ContactAnnotationStore^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactAnnotationStore^ UnwrapContactAnnotationStore(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactCardOptions(::Windows::ApplicationModel::Contacts::ContactCardOptions^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactCardOptions^ UnwrapContactCardOptions(Local<Value> value);
  
  v8::Local<v8::Value> WrapFullContactCardOptions(::Windows::ApplicationModel::Contacts::FullContactCardOptions^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::FullContactCardOptions^ UnwrapFullContactCardOptions(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactManagerForUser(::Windows::ApplicationModel::Contacts::ContactManagerForUser^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactManagerForUser^ UnwrapContactManagerForUser(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactAnnotation(::Windows::ApplicationModel::Contacts::ContactAnnotation^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactAnnotation^ UnwrapContactAnnotation(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactAnnotationList(::Windows::ApplicationModel::Contacts::ContactAnnotationList^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactAnnotationList^ UnwrapContactAnnotationList(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactChangeTracker(::Windows::ApplicationModel::Contacts::ContactChangeTracker^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactChangeTracker^ UnwrapContactChangeTracker(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactChangedEventArgs(::Windows::ApplicationModel::Contacts::ContactChangedEventArgs^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactChangedEventArgs^ UnwrapContactChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapAggregateContactManager(::Windows::ApplicationModel::Contacts::AggregateContactManager^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::AggregateContactManager^ UnwrapAggregateContactManager(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactList(::Windows::ApplicationModel::Contacts::ContactList^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactList^ UnwrapContactList(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactReader(::Windows::ApplicationModel::Contacts::ContactReader^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactReader^ UnwrapContactReader(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactQueryOptions(::Windows::ApplicationModel::Contacts::ContactQueryOptions^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactQueryOptions^ UnwrapContactQueryOptions(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactListSyncManager(::Windows::ApplicationModel::Contacts::ContactListSyncManager^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactListSyncManager^ UnwrapContactListSyncManager(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactListSyncConstraints(::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^ UnwrapContactListSyncConstraints(Local<Value> value);
  
  v8::Local<v8::Value> WrapIContactField(::Windows::ApplicationModel::Contacts::IContactField^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::IContactField^ UnwrapIContactField(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactPhone(::Windows::ApplicationModel::Contacts::ContactPhone^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactPhone^ UnwrapContactPhone(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactEmail(::Windows::ApplicationModel::Contacts::ContactEmail^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactEmail^ UnwrapContactEmail(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactAddress(::Windows::ApplicationModel::Contacts::ContactAddress^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactAddress^ UnwrapContactAddress(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactConnectedServiceAccount(::Windows::ApplicationModel::Contacts::ContactConnectedServiceAccount^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactConnectedServiceAccount^ UnwrapContactConnectedServiceAccount(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactDate(::Windows::ApplicationModel::Contacts::ContactDate^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactDate^ UnwrapContactDate(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactJobInfo(::Windows::ApplicationModel::Contacts::ContactJobInfo^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactJobInfo^ UnwrapContactJobInfo(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactSignificantOther(::Windows::ApplicationModel::Contacts::ContactSignificantOther^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactSignificantOther^ UnwrapContactSignificantOther(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactWebsite(::Windows::ApplicationModel::Contacts::ContactWebsite^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactWebsite^ UnwrapContactWebsite(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactChangedDeferral(::Windows::ApplicationModel::Contacts::ContactChangedDeferral^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactChangedDeferral^ UnwrapContactChangedDeferral(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactChange(::Windows::ApplicationModel::Contacts::ContactChange^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactChange^ UnwrapContactChange(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactChangeReader(::Windows::ApplicationModel::Contacts::ContactChangeReader^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactChangeReader^ UnwrapContactChangeReader(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactBatch(::Windows::ApplicationModel::Contacts::ContactBatch^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactBatch^ UnwrapContactBatch(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactMatchReason(::Windows::ApplicationModel::Contacts::ContactMatchReason^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactMatchReason^ UnwrapContactMatchReason(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactQueryTextSearch(::Windows::ApplicationModel::Contacts::ContactQueryTextSearch^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactQueryTextSearch^ UnwrapContactQueryTextSearch(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactStoreNotificationTriggerDetails(::Windows::ApplicationModel::Contacts::ContactStoreNotificationTriggerDetails^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactStoreNotificationTriggerDetails^ UnwrapContactStoreNotificationTriggerDetails(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactManager(::Windows::ApplicationModel::Contacts::ContactManager^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactManager^ UnwrapContactManager(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactLaunchActionVerbs(::Windows::ApplicationModel::Contacts::ContactLaunchActionVerbs^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactLaunchActionVerbs^ UnwrapContactLaunchActionVerbs(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactField(::Windows::ApplicationModel::Contacts::ContactField^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactField^ UnwrapContactField(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactLocationField(::Windows::ApplicationModel::Contacts::ContactLocationField^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactLocationField^ UnwrapContactLocationField(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactInstantMessageField(::Windows::ApplicationModel::Contacts::ContactInstantMessageField^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactInstantMessageField^ UnwrapContactInstantMessageField(Local<Value> value);
  
  v8::Local<v8::Value> WrapKnownContactField(::Windows::ApplicationModel::Contacts::KnownContactField^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::KnownContactField^ UnwrapKnownContactField(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactInformation(::Windows::ApplicationModel::Contacts::ContactInformation^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactInformation^ UnwrapContactInformation(Local<Value> value);
  
  v8::Local<v8::Value> WrapIContactFieldFactory(::Windows::ApplicationModel::Contacts::IContactFieldFactory^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::IContactFieldFactory^ UnwrapIContactFieldFactory(Local<Value> value);
  
  v8::Local<v8::Value> WrapIContactLocationFieldFactory(::Windows::ApplicationModel::Contacts::IContactLocationFieldFactory^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::IContactLocationFieldFactory^ UnwrapIContactLocationFieldFactory(Local<Value> value);
  
  v8::Local<v8::Value> WrapIContactInstantMessageFieldFactory(::Windows::ApplicationModel::Contacts::IContactInstantMessageFieldFactory^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::IContactInstantMessageFieldFactory^ UnwrapIContactInstantMessageFieldFactory(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactFieldFactory(::Windows::ApplicationModel::Contacts::ContactFieldFactory^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactFieldFactory^ UnwrapContactFieldFactory(Local<Value> value);
  
  v8::Local<v8::Value> WrapContactPicker(::Windows::ApplicationModel::Contacts::ContactPicker^ wintRtInstance);
  ::Windows::ApplicationModel::Contacts::ContactPicker^ UnwrapContactPicker(Local<Value> value);
  



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

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

    Nan::Set(exports, Nan::New<String>("ContactFieldType").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("email").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactFieldType::Email)));
    Nan::Set(enumObject, Nan::New<String>("phoneNumber").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactFieldType::PhoneNumber)));
    Nan::Set(enumObject, Nan::New<String>("location").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactFieldType::Location)));
    Nan::Set(enumObject, Nan::New<String>("instantMessage").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactFieldType::InstantMessage)));
    Nan::Set(enumObject, Nan::New<String>("custom").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactFieldType::Custom)));
    Nan::Set(enumObject, Nan::New<String>("connectedServiceAccount").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactFieldType::ConnectedServiceAccount)));
    Nan::Set(enumObject, Nan::New<String>("importantDate").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactFieldType::ImportantDate)));
    Nan::Set(enumObject, Nan::New<String>("address").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactFieldType::Address)));
    Nan::Set(enumObject, Nan::New<String>("significantOther").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactFieldType::SignificantOther)));
    Nan::Set(enumObject, Nan::New<String>("notes").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactFieldType::Notes)));
    Nan::Set(enumObject, Nan::New<String>("website").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactFieldType::Website)));
    Nan::Set(enumObject, Nan::New<String>("jobInfo").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactFieldType::JobInfo)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ContactSelectionMode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("contacts").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactSelectionMode::Contacts)));
    Nan::Set(enumObject, Nan::New<String>("fields").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactSelectionMode::Fields)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ContactEmailKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("personal").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactEmailKind::Personal)));
    Nan::Set(enumObject, Nan::New<String>("work").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactEmailKind::Work)));
    Nan::Set(enumObject, Nan::New<String>("other").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactEmailKind::Other)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ContactPhoneKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("home").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactPhoneKind::Home)));
    Nan::Set(enumObject, Nan::New<String>("mobile").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactPhoneKind::Mobile)));
    Nan::Set(enumObject, Nan::New<String>("work").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactPhoneKind::Work)));
    Nan::Set(enumObject, Nan::New<String>("other").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactPhoneKind::Other)));
    Nan::Set(enumObject, Nan::New<String>("pager").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactPhoneKind::Pager)));
    Nan::Set(enumObject, Nan::New<String>("businessFax").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactPhoneKind::BusinessFax)));
    Nan::Set(enumObject, Nan::New<String>("homeFax").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactPhoneKind::HomeFax)));
    Nan::Set(enumObject, Nan::New<String>("company").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactPhoneKind::Company)));
    Nan::Set(enumObject, Nan::New<String>("assistant").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactPhoneKind::Assistant)));
    Nan::Set(enumObject, Nan::New<String>("radio").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactPhoneKind::Radio)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ContactAddressKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("home").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactAddressKind::Home)));
    Nan::Set(enumObject, Nan::New<String>("work").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactAddressKind::Work)));
    Nan::Set(enumObject, Nan::New<String>("other").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactAddressKind::Other)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ContactDateKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("birthday").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactDateKind::Birthday)));
    Nan::Set(enumObject, Nan::New<String>("anniversary").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactDateKind::Anniversary)));
    Nan::Set(enumObject, Nan::New<String>("other").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactDateKind::Other)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ContactChangeType").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("created").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactChangeType::Created)));
    Nan::Set(enumObject, Nan::New<String>("modified").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactChangeType::Modified)));
    Nan::Set(enumObject, Nan::New<String>("deleted").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactChangeType::Deleted)));
    Nan::Set(enumObject, Nan::New<String>("changeTrackingLost").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactChangeType::ChangeTrackingLost)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ContactRelationship").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("other").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactRelationship::Other)));
    Nan::Set(enumObject, Nan::New<String>("spouse").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactRelationship::Spouse)));
    Nan::Set(enumObject, Nan::New<String>("partner").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactRelationship::Partner)));
    Nan::Set(enumObject, Nan::New<String>("sibling").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactRelationship::Sibling)));
    Nan::Set(enumObject, Nan::New<String>("parent").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactRelationship::Parent)));
    Nan::Set(enumObject, Nan::New<String>("child").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactRelationship::Child)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ContactQueryDesiredFields").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactQueryDesiredFields::None)));
    Nan::Set(enumObject, Nan::New<String>("phoneNumber").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactQueryDesiredFields::PhoneNumber)));
    Nan::Set(enumObject, Nan::New<String>("emailAddress").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactQueryDesiredFields::EmailAddress)));
    Nan::Set(enumObject, Nan::New<String>("postalAddress").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactQueryDesiredFields::PostalAddress)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ContactQuerySearchFields").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactQuerySearchFields::None)));
    Nan::Set(enumObject, Nan::New<String>("name").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactQuerySearchFields::Name)));
    Nan::Set(enumObject, Nan::New<String>("email").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactQuerySearchFields::Email)));
    Nan::Set(enumObject, Nan::New<String>("phone").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactQuerySearchFields::Phone)));
    Nan::Set(enumObject, Nan::New<String>("all").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactQuerySearchFields::All)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ContactQuerySearchScope").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("local").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactQuerySearchScope::Local)));
    Nan::Set(enumObject, Nan::New<String>("server").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactQuerySearchScope::Server)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ContactStoreAccessType").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("appContactsReadWrite").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactStoreAccessType::AppContactsReadWrite)));
    Nan::Set(enumObject, Nan::New<String>("allContactsReadOnly").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactStoreAccessType::AllContactsReadOnly)));
    Nan::Set(enumObject, Nan::New<String>("allContactsReadWrite").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactStoreAccessType::AllContactsReadWrite)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ContactAnnotationStoreAccessType").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("appAnnotationsReadWrite").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactAnnotationStoreAccessType::AppAnnotationsReadWrite)));
    Nan::Set(enumObject, Nan::New<String>("allAnnotationsReadWrite").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactAnnotationStoreAccessType::AllAnnotationsReadWrite)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ContactListOtherAppReadAccess").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("systemOnly").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactListOtherAppReadAccess::SystemOnly)));
    Nan::Set(enumObject, Nan::New<String>("limited").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactListOtherAppReadAccess::Limited)));
    Nan::Set(enumObject, Nan::New<String>("full").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactListOtherAppReadAccess::Full)));
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactListOtherAppReadAccess::None)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ContactListOtherAppWriteAccess").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactListOtherAppWriteAccess::None)));
    Nan::Set(enumObject, Nan::New<String>("systemOnly").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactListOtherAppWriteAccess::SystemOnly)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ContactMatchReasonKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("name").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactMatchReasonKind::Name)));
    Nan::Set(enumObject, Nan::New<String>("emailAddress").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactMatchReasonKind::EmailAddress)));
    Nan::Set(enumObject, Nan::New<String>("phoneNumber").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactMatchReasonKind::PhoneNumber)));
    Nan::Set(enumObject, Nan::New<String>("jobInfo").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactMatchReasonKind::JobInfo)));
    Nan::Set(enumObject, Nan::New<String>("yomiName").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactMatchReasonKind::YomiName)));
    Nan::Set(enumObject, Nan::New<String>("other").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactMatchReasonKind::Other)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ContactBatchStatus").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("success").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactBatchStatus::Success)));
    Nan::Set(enumObject, Nan::New<String>("serverSearchSyncManagerError").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactBatchStatus::ServerSearchSyncManagerError)));
    Nan::Set(enumObject, Nan::New<String>("serverSearchUnknownError").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactBatchStatus::ServerSearchUnknownError)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ContactAnnotationOperations").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactAnnotationOperations::None)));
    Nan::Set(enumObject, Nan::New<String>("contactProfile").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactAnnotationOperations::ContactProfile)));
    Nan::Set(enumObject, Nan::New<String>("message").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactAnnotationOperations::Message)));
    Nan::Set(enumObject, Nan::New<String>("audioCall").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactAnnotationOperations::AudioCall)));
    Nan::Set(enumObject, Nan::New<String>("videoCall").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactAnnotationOperations::VideoCall)));
    Nan::Set(enumObject, Nan::New<String>("socialFeeds").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactAnnotationOperations::SocialFeeds)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ContactNameOrder").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("firstNameLastName").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactNameOrder::FirstNameLastName)));
    Nan::Set(enumObject, Nan::New<String>("lastNameFirstName").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactNameOrder::LastNameFirstName)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ContactListSyncStatus").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("idle").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactListSyncStatus::Idle)));
    Nan::Set(enumObject, Nan::New<String>("syncing").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactListSyncStatus::Syncing)));
    Nan::Set(enumObject, Nan::New<String>("upToDate").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactListSyncStatus::UpToDate)));
    Nan::Set(enumObject, Nan::New<String>("authenticationError").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactListSyncStatus::AuthenticationError)));
    Nan::Set(enumObject, Nan::New<String>("policyError").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactListSyncStatus::PolicyError)));
    Nan::Set(enumObject, Nan::New<String>("unknownError").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactListSyncStatus::UnknownError)));
    Nan::Set(enumObject, Nan::New<String>("manualAccountRemovalRequired").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactListSyncStatus::ManualAccountRemovalRequired)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ContactCardHeaderKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("default").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactCardHeaderKind::Default)));
    Nan::Set(enumObject, Nan::New<String>("basic").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactCardHeaderKind::Basic)));
    Nan::Set(enumObject, Nan::New<String>("enterprise").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactCardHeaderKind::Enterprise)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ContactCardTabKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("default").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactCardTabKind::Default)));
    Nan::Set(enumObject, Nan::New<String>("email").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactCardTabKind::Email)));
    Nan::Set(enumObject, Nan::New<String>("messaging").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactCardTabKind::Messaging)));
    Nan::Set(enumObject, Nan::New<String>("phone").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactCardTabKind::Phone)));
    Nan::Set(enumObject, Nan::New<String>("video").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactCardTabKind::Video)));
    Nan::Set(enumObject, Nan::New<String>("organizationalHierarchy").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactCardTabKind::OrganizationalHierarchy)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ContactFieldCategory").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactFieldCategory::None)));
    Nan::Set(enumObject, Nan::New<String>("home").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactFieldCategory::Home)));
    Nan::Set(enumObject, Nan::New<String>("work").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactFieldCategory::Work)));
    Nan::Set(enumObject, Nan::New<String>("mobile").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactFieldCategory::Mobile)));
    Nan::Set(enumObject, Nan::New<String>("other").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Contacts::ContactFieldCategory::Other)));
  }


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

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

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

  ::Windows::Data::Text::TextSegment TextSegmentFromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::Data::Text::TextSegment 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>("startPosition").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.StartPosition = static_cast<unsigned int>(Nan::To<uint32_t>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0));
    }
    
    symbol = Nan::New<String>("length").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.Length = static_cast<unsigned int>(Nan::To<uint32_t>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0));
    }
    
    return returnValue;
  }

  Local<Value> TextSegmentToJsObject(::Windows::Data::Text::TextSegment value) {
    EscapableHandleScope scope;

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

    Nan::Set(obj, Nan::New<String>("startPosition").ToLocalChecked(), Nan::New<Integer>(value.StartPosition));
    Nan::Set(obj, Nan::New<String>("length").ToLocalChecked(), Nan::New<Integer>(value.Length));

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

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

    return true;
  }

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

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

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

    return returnValue;
  }

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

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


    return scope.Escape(obj);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("thumbnail").ToLocalChecked(), ThumbnailGetter, ThumbnailSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("name").ToLocalChecked(), NameGetter, NameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("fields").ToLocalChecked(), FieldsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("id").ToLocalChecked(), IdGetter, IdSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("notes").ToLocalChecked(), NotesGetter, NotesSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("connectedServiceAccounts").ToLocalChecked(), ConnectedServiceAccountsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("emails").ToLocalChecked(), EmailsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("addresses").ToLocalChecked(), AddressesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("importantDates").ToLocalChecked(), ImportantDatesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("jobInfo").ToLocalChecked(), JobInfoGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dataSuppliers").ToLocalChecked(), DataSuppliersGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("phones").ToLocalChecked(), PhonesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("providerProperties").ToLocalChecked(), ProviderPropertiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("significantOthers").ToLocalChecked(), SignificantOthersGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("websites").ToLocalChecked(), WebsitesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("sourceDisplayPicture").ToLocalChecked(), SourceDisplayPictureGetter, SourceDisplayPictureSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("textToneToken").ToLocalChecked(), TextToneTokenGetter, TextToneTokenSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("displayNameOverride").ToLocalChecked(), DisplayNameOverrideGetter, DisplayNameOverrideSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("displayPictureUserUpdateTime").ToLocalChecked(), DisplayPictureUserUpdateTimeGetter, DisplayPictureUserUpdateTimeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("nickname").ToLocalChecked(), NicknameGetter, NicknameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("remoteId").ToLocalChecked(), RemoteIdGetter, RemoteIdSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("ringToneToken").ToLocalChecked(), RingToneTokenGetter, RingToneTokenSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("contactListId").ToLocalChecked(), ContactListIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("largeDisplayPicture").ToLocalChecked(), LargeDisplayPictureGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("smallDisplayPicture").ToLocalChecked(), SmallDisplayPictureGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("sortName").ToLocalChecked(), SortNameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("aggregateId").ToLocalChecked(), AggregateIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("fullName").ToLocalChecked(), FullNameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isAggregate").ToLocalChecked(), IsAggregateGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isDisplayPictureManuallySet").ToLocalChecked(), IsDisplayPictureManuallySetGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isMe").ToLocalChecked(), IsMeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("yomiGivenName").ToLocalChecked(), YomiGivenNameGetter, YomiGivenNameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("honorificNameSuffix").ToLocalChecked(), HonorificNameSuffixGetter, HonorificNameSuffixSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("yomiFamilyName").ToLocalChecked(), YomiFamilyNameGetter, YomiFamilyNameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("middleName").ToLocalChecked(), MiddleNameGetter, MiddleNameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("lastName").ToLocalChecked(), LastNameGetter, LastNameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("honorificNamePrefix").ToLocalChecked(), HonorificNamePrefixGetter, HonorificNamePrefixSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("firstName").ToLocalChecked(), FirstNameGetter, FirstNameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("displayName").ToLocalChecked(), DisplayNameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("yomiDisplayName").ToLocalChecked(), YomiDisplayNameGetter);

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



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

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

    private:

      Contact(::Windows::ApplicationModel::Contacts::Contact^ 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::ApplicationModel::Contacts::Contact^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Storage::Streams::IRandomAccessStreamReference^ winRtValue = dynamic_cast<::Windows::Storage::Streams::IRandomAccessStreamReference^>(NodeRT::Utils::GetObjectInstance(value));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::ApplicationModel::Contacts::IContactField^>^ result = wrapper->_instance->Fields;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::ApplicationModel::Contacts::IContactField^>::CreateVectorWrapper(result, 
            [](::Windows::ApplicationModel::Contacts::IContactField^ val) -> Local<Value> {
              return WrapIContactField(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::IContactField^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Contacts::IContactField^ {
              return UnwrapIContactField(value);
            }
          ));
        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::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

      Contact *wrapper = Contact::Unwrap<Contact>(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 IdSetter(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::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::ApplicationModel::Contacts::ContactConnectedServiceAccount^>^ result = wrapper->_instance->ConnectedServiceAccounts;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::ApplicationModel::Contacts::ContactConnectedServiceAccount^>::CreateVectorWrapper(result, 
            [](::Windows::ApplicationModel::Contacts::ContactConnectedServiceAccount^ val) -> Local<Value> {
              return WrapContactConnectedServiceAccount(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactConnectedServiceAccount^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Contacts::ContactConnectedServiceAccount^ {
              return UnwrapContactConnectedServiceAccount(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void EmailsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::ApplicationModel::Contacts::ContactEmail^>^ result = wrapper->_instance->Emails;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::ApplicationModel::Contacts::ContactEmail^>::CreateVectorWrapper(result, 
            [](::Windows::ApplicationModel::Contacts::ContactEmail^ val) -> Local<Value> {
              return WrapContactEmail(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactEmail^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Contacts::ContactEmail^ {
              return UnwrapContactEmail(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AddressesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::ApplicationModel::Contacts::ContactAddress^>^ result = wrapper->_instance->Addresses;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::ApplicationModel::Contacts::ContactAddress^>::CreateVectorWrapper(result, 
            [](::Windows::ApplicationModel::Contacts::ContactAddress^ val) -> Local<Value> {
              return WrapContactAddress(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAddress^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Contacts::ContactAddress^ {
              return UnwrapContactAddress(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ImportantDatesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::ApplicationModel::Contacts::ContactDate^>^ result = wrapper->_instance->ImportantDates;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::ApplicationModel::Contacts::ContactDate^>::CreateVectorWrapper(result, 
            [](::Windows::ApplicationModel::Contacts::ContactDate^ val) -> Local<Value> {
              return WrapContactDate(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactDate^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Contacts::ContactDate^ {
              return UnwrapContactDate(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void JobInfoGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::ApplicationModel::Contacts::ContactJobInfo^>^ result = wrapper->_instance->JobInfo;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::ApplicationModel::Contacts::ContactJobInfo^>::CreateVectorWrapper(result, 
            [](::Windows::ApplicationModel::Contacts::ContactJobInfo^ val) -> Local<Value> {
              return WrapContactJobInfo(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactJobInfo^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Contacts::ContactJobInfo^ {
              return UnwrapContactJobInfo(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DataSuppliersGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::ApplicationModel::Contacts::ContactPhone^>^ result = wrapper->_instance->Phones;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::ApplicationModel::Contacts::ContactPhone^>::CreateVectorWrapper(result, 
            [](::Windows::ApplicationModel::Contacts::ContactPhone^ val) -> Local<Value> {
              return WrapContactPhone(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactPhone^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Contacts::ContactPhone^ {
              return UnwrapContactPhone(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ProviderPropertiesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::ApplicationModel::Contacts::ContactSignificantOther^>^ result = wrapper->_instance->SignificantOthers;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::ApplicationModel::Contacts::ContactSignificantOther^>::CreateVectorWrapper(result, 
            [](::Windows::ApplicationModel::Contacts::ContactSignificantOther^ val) -> Local<Value> {
              return WrapContactSignificantOther(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactSignificantOther^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Contacts::ContactSignificantOther^ {
              return UnwrapContactSignificantOther(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void WebsitesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::ApplicationModel::Contacts::ContactWebsite^>^ result = wrapper->_instance->Websites;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::ApplicationModel::Contacts::ContactWebsite^>::CreateVectorWrapper(result, 
            [](::Windows::ApplicationModel::Contacts::ContactWebsite^ val) -> Local<Value> {
              return WrapContactWebsite(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactWebsite^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Contacts::ContactWebsite^ {
              return UnwrapContactWebsite(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SourceDisplayPictureGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Storage::Streams::IRandomAccessStreamReference^ winRtValue = dynamic_cast<::Windows::Storage::Streams::IRandomAccessStreamReference^>(NodeRT::Utils::GetObjectInstance(value));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Foundation::DateTime winRtValue = NodeRT::Utils::DateTimeFromJSDate(value);

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

      Contact *wrapper = Contact::Unwrap<Contact>(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 NicknameSetter(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::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::ApplicationModel::Contacts::Contact^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContact(::Windows::ApplicationModel::Contacts::Contact^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::Contact^ UnwrapContact(Local<Value> value);
  };

  Persistent<FunctionTemplate> Contact::s_constructorTemplate;

  v8::Local<v8::Value> WrapContact(::Windows::ApplicationModel::Contacts::Contact^ 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>(Contact::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::Contact^ UnwrapContact(Local<Value> value) {
     return Contact::Unwrap<Contact>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContact(Local<Object> exports) {
    Contact::Init(exports);
  }

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


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




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



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

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

    private:

      ContactCardDelayedDataLoader(::Windows::ApplicationModel::Contacts::ContactCardDelayedDataLoader^ 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::ApplicationModel::Contacts::ContactCardDelayedDataLoader^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactCardDelayedDataLoader^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::Contact^ arg0 = UnwrapContact(info[0]);
          
          wrapper->_instance->SetData(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 Close(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactCardDelayedDataLoader^>(info.This())) {
        return;
      }

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

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





    private:
      ::Windows::ApplicationModel::Contacts::ContactCardDelayedDataLoader^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactCardDelayedDataLoader(::Windows::ApplicationModel::Contacts::ContactCardDelayedDataLoader^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactCardDelayedDataLoader^ UnwrapContactCardDelayedDataLoader(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactCardDelayedDataLoader::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactCardDelayedDataLoader(::Windows::ApplicationModel::Contacts::ContactCardDelayedDataLoader^ 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>(ContactCardDelayedDataLoader::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactCardDelayedDataLoader^ UnwrapContactCardDelayedDataLoader(Local<Value> value) {
     return ContactCardDelayedDataLoader::Unwrap<ContactCardDelayedDataLoader>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactCardDelayedDataLoader(Local<Object> exports) {
    ContactCardDelayedDataLoader::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "getContactReader", GetContactReader);
          

          
            Nan::SetPrototypeMethod(localRef, "findContactsAsync", FindContactsAsync);
            Nan::SetPrototypeMethod(localRef, "getContactAsync", GetContactAsync);
            Nan::SetPrototypeMethod(localRef, "findContactListsAsync", FindContactListsAsync);
            Nan::SetPrototypeMethod(localRef, "getContactListAsync", GetContactListAsync);
            Nan::SetPrototypeMethod(localRef, "createContactListAsync", CreateContactListAsync);
            Nan::SetPrototypeMethod(localRef, "getMeContactAsync", GetMeContactAsync);
          

          
          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>("aggregateContactManager").ToLocalChecked(), AggregateContactManagerGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("changeTracker").ToLocalChecked(), ChangeTrackerGetter);

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



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

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

    private:

      ContactStore(::Windows::ApplicationModel::Contacts::ContactStore^ 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::ApplicationModel::Contacts::ContactStore^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactStore^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Contacts::Contact^>^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->FindContactsAsync();
        }
        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->FindContactsAsync(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::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Contacts::Contact^>^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactStore^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::ApplicationModel::Contacts::Contact^>^ 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->GetContactAsync(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::ApplicationModel::Contacts::Contact^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactStore^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Contacts::ContactList^>^>^ op;


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

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactStore^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::ApplicationModel::Contacts::ContactList^>^ 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->GetContactListAsync(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::ApplicationModel::Contacts::ContactList^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactStore^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::ApplicationModel::Contacts::ContactList^>^ 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->CreateContactListAsync(arg0);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else 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->CreateContactListAsync(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::ApplicationModel::Contacts::ContactList^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactStore^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::ApplicationModel::Contacts::Contact^>^ op;


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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactStore^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::ContactReader^ result;
          result = wrapper->_instance->GetContactReader();
          info.GetReturnValue().Set(WrapContactReader(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactQueryOptions^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::ContactQueryOptions^ arg0 = UnwrapContactQueryOptions(info[0]);
          
          ::Windows::ApplicationModel::Contacts::ContactReader^ result;
          result = wrapper->_instance->GetContactReader(arg0);
          info.GetReturnValue().Set(WrapContactReader(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 AggregateContactManagerGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactStore^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactStore^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::ApplicationModel::Contacts::ContactChangeTracker^ result = wrapper->_instance->ChangeTracker;
        info.GetReturnValue().Set(WrapContactChangeTracker(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"contactChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactStore^>(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;
        }
        ContactStore *wrapper = ContactStore::Unwrap<ContactStore>(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->ContactChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::ApplicationModel::Contacts::ContactStore^, ::Windows::ApplicationModel::Contacts::ContactChangedEventArgs^>(
            [callbackObjPtr](::Windows::ApplicationModel::Contacts::ContactStore^ arg0, ::Windows::ApplicationModel::Contacts::ContactChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapContactStore(arg0);
                  wrappedArg1 = WrapContactChangedEventArgs(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"contactChanged", 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"contactChanged", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactStore^>(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;
          }
          ContactStore *wrapper = ContactStore::Unwrap<ContactStore>(info.This());
          wrapper->_instance->ContactChanged::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::ApplicationModel::Contacts::ContactStore^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactStore(::Windows::ApplicationModel::Contacts::ContactStore^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactStore^ UnwrapContactStore(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactStore::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactStore(::Windows::ApplicationModel::Contacts::ContactStore^ 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>(ContactStore::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactStore^ UnwrapContactStore(Local<Value> value) {
     return ContactStore::Unwrap<ContactStore>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactStore(Local<Object> exports) {
    ContactStore::Init(exports);
  }

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

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


          
            Nan::SetPrototypeMethod(localRef, "findContactIdsByEmailAsync", FindContactIdsByEmailAsync);
            Nan::SetPrototypeMethod(localRef, "findContactIdsByPhoneNumberAsync", FindContactIdsByPhoneNumberAsync);
            Nan::SetPrototypeMethod(localRef, "findAnnotationsForContactAsync", FindAnnotationsForContactAsync);
            Nan::SetPrototypeMethod(localRef, "disableAnnotationAsync", DisableAnnotationAsync);
            Nan::SetPrototypeMethod(localRef, "createAnnotationListAsync", CreateAnnotationListAsync);
            Nan::SetPrototypeMethod(localRef, "getAnnotationListAsync", GetAnnotationListAsync);
            Nan::SetPrototypeMethod(localRef, "findAnnotationListsAsync", FindAnnotationListsAsync);
          



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



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

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

    private:

      ContactAnnotationStore(::Windows::ApplicationModel::Contacts::ContactAnnotationStore^ 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::ApplicationModel::Contacts::ContactAnnotationStore^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAnnotationStore^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Foundation::Collections::IVectorView<::Platform::String^>^>^ 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->FindContactIdsByEmailAsync(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::Foundation::Collections::IVectorView<::Platform::String^>^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = NodeRT::Collections::VectorViewWrapper<::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)));
            }
          );
              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 FindContactIdsByPhoneNumberAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAnnotationStore^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Foundation::Collections::IVectorView<::Platform::String^>^>^ 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->FindContactIdsByPhoneNumberAsync(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::Foundation::Collections::IVectorView<::Platform::String^>^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = NodeRT::Collections::VectorViewWrapper<::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)));
            }
          );
              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 FindAnnotationsForContactAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAnnotationStore^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Contacts::ContactAnnotation^>^>^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::Contact^ arg0 = UnwrapContact(info[0]);
          
          op = wrapper->_instance->FindAnnotationsForContactAsync(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::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Contacts::ContactAnnotation^>^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAnnotationStore^>(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;
      }

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

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


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAnnotation^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::ContactAnnotation^ arg0 = UnwrapContactAnnotation(info[0]);
          
          op = wrapper->_instance->DisableAnnotationAsync(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 CreateAnnotationListAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAnnotationStore^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::ApplicationModel::Contacts::ContactAnnotationList^>^ op;


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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAnnotationStore^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::ApplicationModel::Contacts::ContactAnnotationList^>^ 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->GetAnnotationListAsync(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::ApplicationModel::Contacts::ContactAnnotationList^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAnnotationStore^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Contacts::ContactAnnotationList^>^>^ op;


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

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

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


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


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

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






    private:
      ::Windows::ApplicationModel::Contacts::ContactAnnotationStore^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactAnnotationStore(::Windows::ApplicationModel::Contacts::ContactAnnotationStore^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactAnnotationStore^ UnwrapContactAnnotationStore(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactAnnotationStore::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactAnnotationStore(::Windows::ApplicationModel::Contacts::ContactAnnotationStore^ 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>(ContactAnnotationStore::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactAnnotationStore^ UnwrapContactAnnotationStore(Local<Value> value) {
     return ContactAnnotationStore::Unwrap<ContactAnnotationStore>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactAnnotationStore(Local<Object> exports) {
    ContactAnnotationStore::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("initialTabKind").ToLocalChecked(), InitialTabKindGetter, InitialTabKindSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("headerKind").ToLocalChecked(), HeaderKindGetter, HeaderKindSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("serverSearchContactListIds").ToLocalChecked(), ServerSearchContactListIdsGetter);

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



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

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

    private:

      ContactCardOptions(::Windows::ApplicationModel::Contacts::ContactCardOptions^ 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::ApplicationModel::Contacts::ContactCardOptions^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactCardOptions^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::ApplicationModel::Contacts::ContactCardTabKind result = wrapper->_instance->InitialTabKind;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void InitialTabKindSetter(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::ApplicationModel::Contacts::ContactCardOptions^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::ApplicationModel::Contacts::ContactCardTabKind winRtValue = static_cast<::Windows::ApplicationModel::Contacts::ContactCardTabKind>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactCardOptions^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::ApplicationModel::Contacts::ContactCardHeaderKind result = wrapper->_instance->HeaderKind;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void HeaderKindSetter(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::ApplicationModel::Contacts::ContactCardOptions^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::ApplicationModel::Contacts::ContactCardHeaderKind winRtValue = static_cast<::Windows::ApplicationModel::Contacts::ContactCardHeaderKind>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactCardOptions^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::ApplicationModel::Contacts::ContactCardOptions^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactCardOptions(::Windows::ApplicationModel::Contacts::ContactCardOptions^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactCardOptions^ UnwrapContactCardOptions(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactCardOptions::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactCardOptions(::Windows::ApplicationModel::Contacts::ContactCardOptions^ 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>(ContactCardOptions::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactCardOptions^ UnwrapContactCardOptions(Local<Value> value) {
     return ContactCardOptions::Unwrap<ContactCardOptions>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactCardOptions(Local<Object> exports) {
    ContactCardOptions::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("desiredRemainingView").ToLocalChecked(), DesiredRemainingViewGetter, DesiredRemainingViewSetter);

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



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

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

    private:

      FullContactCardOptions(::Windows::ApplicationModel::Contacts::FullContactCardOptions^ 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::ApplicationModel::Contacts::FullContactCardOptions^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::FullContactCardOptions^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::UI::ViewManagement::ViewSizePreference result = wrapper->_instance->DesiredRemainingView;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DesiredRemainingViewSetter(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::ApplicationModel::Contacts::FullContactCardOptions^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::UI::ViewManagement::ViewSizePreference winRtValue = static_cast<::Windows::UI::ViewManagement::ViewSizePreference>(Nan::To<int32_t>(value).FromMaybe(0));

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


    private:
      ::Windows::ApplicationModel::Contacts::FullContactCardOptions^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapFullContactCardOptions(::Windows::ApplicationModel::Contacts::FullContactCardOptions^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::FullContactCardOptions^ UnwrapFullContactCardOptions(Local<Value> value);
  };

  Persistent<FunctionTemplate> FullContactCardOptions::s_constructorTemplate;

  v8::Local<v8::Value> WrapFullContactCardOptions(::Windows::ApplicationModel::Contacts::FullContactCardOptions^ 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>(FullContactCardOptions::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::FullContactCardOptions^ UnwrapFullContactCardOptions(Local<Value> value) {
     return FullContactCardOptions::Unwrap<FullContactCardOptions>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitFullContactCardOptions(Local<Object> exports) {
    FullContactCardOptions::Init(exports);
  }

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

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


          
            Nan::SetPrototypeMethod(localRef, "convertContactToVCardAsync", ConvertContactToVCardAsync);
            Nan::SetPrototypeMethod(localRef, "convertVCardToContactAsync", ConvertVCardToContactAsync);
            Nan::SetPrototypeMethod(localRef, "requestStoreAsync", RequestStoreAsync);
            Nan::SetPrototypeMethod(localRef, "requestAnnotationStoreAsync", RequestAnnotationStoreAsync);
          


          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("systemSortOrder").ToLocalChecked(), SystemSortOrderGetter, SystemSortOrderSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("systemDisplayNameOrder").ToLocalChecked(), SystemDisplayNameOrderGetter, SystemDisplayNameOrderSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("user").ToLocalChecked(), UserGetter);

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



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

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

    private:

      ContactManagerForUser(::Windows::ApplicationModel::Contacts::ContactManagerForUser^ 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::ApplicationModel::Contacts::ContactManagerForUser^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactManagerForUser^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Storage::Streams::RandomAccessStreamReference^>^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::Contact^ arg0 = UnwrapContact(info[0]);
          
          op = wrapper->_instance->ConvertContactToVCardAsync(arg0);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info[0])
        && info[1]->IsUint32())
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::Contact^ arg0 = UnwrapContact(info[0]);
          unsigned int arg1 = static_cast<unsigned int>(Nan::To<uint32_t>(info[1]).FromMaybe(0));
          
          op = wrapper->_instance->ConvertContactToVCardAsync(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::Storage::Streams::RandomAccessStreamReference^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.Storage.Streams", "RandomAccessStreamReference", 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 ConvertVCardToContactAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactManagerForUser^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::ApplicationModel::Contacts::Contact^>^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IRandomAccessStreamReference^>(info[0]))
      {
        try
        {
          ::Windows::Storage::Streams::IRandomAccessStreamReference^ arg0 = dynamic_cast<::Windows::Storage::Streams::IRandomAccessStreamReference^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          op = wrapper->_instance->ConvertVCardToContactAsync(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::ApplicationModel::Contacts::Contact^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactManagerForUser^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::ApplicationModel::Contacts::ContactStore^>^ op;


      if (info.Length() == 2
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::ContactStoreAccessType arg0 = static_cast<::Windows::ApplicationModel::Contacts::ContactStoreAccessType>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          op = wrapper->_instance->RequestStoreAsync(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::ApplicationModel::Contacts::ContactStore^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactManagerForUser^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::ApplicationModel::Contacts::ContactAnnotationStore^>^ op;


      if (info.Length() == 2
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::ContactAnnotationStoreAccessType arg0 = static_cast<::Windows::ApplicationModel::Contacts::ContactAnnotationStoreAccessType>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          op = wrapper->_instance->RequestAnnotationStoreAsync(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::ApplicationModel::Contacts::ContactAnnotationStore^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactManagerForUser^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::ApplicationModel::Contacts::ContactNameOrder result = wrapper->_instance->SystemSortOrder;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SystemSortOrderSetter(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::ApplicationModel::Contacts::ContactManagerForUser^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::ApplicationModel::Contacts::ContactNameOrder winRtValue = static_cast<::Windows::ApplicationModel::Contacts::ContactNameOrder>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactManagerForUser^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::ApplicationModel::Contacts::ContactNameOrder result = wrapper->_instance->SystemDisplayNameOrder;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SystemDisplayNameOrderSetter(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::ApplicationModel::Contacts::ContactManagerForUser^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::ApplicationModel::Contacts::ContactNameOrder winRtValue = static_cast<::Windows::ApplicationModel::Contacts::ContactNameOrder>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactManagerForUser^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::ApplicationModel::Contacts::ContactManagerForUser^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactManagerForUser(::Windows::ApplicationModel::Contacts::ContactManagerForUser^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactManagerForUser^ UnwrapContactManagerForUser(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactManagerForUser::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactManagerForUser(::Windows::ApplicationModel::Contacts::ContactManagerForUser^ 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>(ContactManagerForUser::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactManagerForUser^ UnwrapContactManagerForUser(Local<Value> value) {
     return ContactManagerForUser::Unwrap<ContactManagerForUser>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactManagerForUser(Local<Object> exports) {
    ContactManagerForUser::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("supportedOperations").ToLocalChecked(), SupportedOperationsGetter, SupportedOperationsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("remoteId").ToLocalChecked(), RemoteIdGetter, RemoteIdSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("contactId").ToLocalChecked(), ContactIdGetter, ContactIdSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("annotationListId").ToLocalChecked(), AnnotationListIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("id").ToLocalChecked(), IdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isDisabled").ToLocalChecked(), IsDisabledGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("providerProperties").ToLocalChecked(), ProviderPropertiesGetter);

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



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

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

    private:

      ContactAnnotation(::Windows::ApplicationModel::Contacts::ContactAnnotation^ 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::ApplicationModel::Contacts::ContactAnnotation^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAnnotation^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::ApplicationModel::Contacts::ContactAnnotationOperations result = wrapper->_instance->SupportedOperations;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SupportedOperationsSetter(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::ApplicationModel::Contacts::ContactAnnotation^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::ApplicationModel::Contacts::ContactAnnotationOperations winRtValue = static_cast<::Windows::ApplicationModel::Contacts::ContactAnnotationOperations>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAnnotation^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAnnotation^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAnnotation^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAnnotation^>(info.This())) {
        return;
      }

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAnnotation^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAnnotation^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::ApplicationModel::Contacts::ContactAnnotation^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactAnnotation(::Windows::ApplicationModel::Contacts::ContactAnnotation^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactAnnotation^ UnwrapContactAnnotation(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactAnnotation::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactAnnotation(::Windows::ApplicationModel::Contacts::ContactAnnotation^ 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>(ContactAnnotation::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactAnnotation^ UnwrapContactAnnotation(Local<Value> value) {
     return ContactAnnotation::Unwrap<ContactAnnotation>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactAnnotation(Local<Object> exports) {
    ContactAnnotation::Init(exports);
  }

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

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


          
            Nan::SetPrototypeMethod(localRef, "deleteAsync", DeleteAsync);
            Nan::SetPrototypeMethod(localRef, "trySaveAnnotationAsync", TrySaveAnnotationAsync);
            Nan::SetPrototypeMethod(localRef, "getAnnotationAsync", GetAnnotationAsync);
            Nan::SetPrototypeMethod(localRef, "findAnnotationsByRemoteIdAsync", FindAnnotationsByRemoteIdAsync);
            Nan::SetPrototypeMethod(localRef, "findAnnotationsAsync", FindAnnotationsAsync);
            Nan::SetPrototypeMethod(localRef, "deleteAnnotationAsync", DeleteAnnotationAsync);
          


          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("id").ToLocalChecked(), IdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("providerPackageFamilyName").ToLocalChecked(), ProviderPackageFamilyNameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("userDataAccountId").ToLocalChecked(), UserDataAccountIdGetter);

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



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

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

    private:

      ContactAnnotationList(::Windows::ApplicationModel::Contacts::ContactAnnotationList^ 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::ApplicationModel::Contacts::ContactAnnotationList^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAnnotationList^>(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;
      }

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAnnotationList^>(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;
      }

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

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


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAnnotation^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::ContactAnnotation^ arg0 = UnwrapContactAnnotation(info[0]);
          
          op = wrapper->_instance->TrySaveAnnotationAsync(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);
          });
        }
      });
    }
    static void GetAnnotationAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAnnotationList^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::ApplicationModel::Contacts::ContactAnnotation^>^ 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->GetAnnotationAsync(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::ApplicationModel::Contacts::ContactAnnotation^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAnnotationList^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Contacts::ContactAnnotation^>^>^ 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->FindAnnotationsByRemoteIdAsync(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::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Contacts::ContactAnnotation^>^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAnnotationList^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Contacts::ContactAnnotation^>^>^ op;


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

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAnnotationList^>(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;
      }

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

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


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAnnotation^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::ContactAnnotation^ arg0 = UnwrapContactAnnotation(info[0]);
          
          op = wrapper->_instance->DeleteAnnotationAsync(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 IdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAnnotationList^>(info.This())) {
        return;
      }

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAnnotationList^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAnnotationList^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::ApplicationModel::Contacts::ContactAnnotationList^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactAnnotationList(::Windows::ApplicationModel::Contacts::ContactAnnotationList^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactAnnotationList^ UnwrapContactAnnotationList(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactAnnotationList::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactAnnotationList(::Windows::ApplicationModel::Contacts::ContactAnnotationList^ 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>(ContactAnnotationList::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactAnnotationList^ UnwrapContactAnnotationList(Local<Value> value) {
     return ContactAnnotationList::Unwrap<ContactAnnotationList>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactAnnotationList(Local<Object> exports) {
    ContactAnnotationList::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "enable", Enable);
            Nan::SetPrototypeMethod(localRef, "getChangeReader", GetChangeReader);
            Nan::SetPrototypeMethod(localRef, "reset", Reset);
          




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



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

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

    private:

      ContactChangeTracker(::Windows::ApplicationModel::Contacts::ContactChangeTracker^ 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::ApplicationModel::Contacts::ContactChangeTracker^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactChangeTracker^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactChangeTracker^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::ContactChangeReader^ result;
          result = wrapper->_instance->GetChangeReader();
          info.GetReturnValue().Set(WrapContactChangeReader(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 Reset(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactChangeTracker^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->Reset();
          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::ApplicationModel::Contacts::ContactChangeTracker^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactChangeTracker(::Windows::ApplicationModel::Contacts::ContactChangeTracker^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactChangeTracker^ UnwrapContactChangeTracker(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactChangeTracker::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactChangeTracker(::Windows::ApplicationModel::Contacts::ContactChangeTracker^ 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>(ContactChangeTracker::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactChangeTracker^ UnwrapContactChangeTracker(Local<Value> value) {
     return ContactChangeTracker::Unwrap<ContactChangeTracker>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactChangeTracker(Local<Object> exports) {
    ContactChangeTracker::Init(exports);
  }

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


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




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



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

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

    private:

      ContactChangedEventArgs(::Windows::ApplicationModel::Contacts::ContactChangedEventArgs^ 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::ApplicationModel::Contacts::ContactChangedEventArgs^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactChangedEventArgs^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::ContactChangedDeferral^ result;
          result = wrapper->_instance->GetDeferral();
          info.GetReturnValue().Set(WrapContactChangedDeferral(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::ApplicationModel::Contacts::ContactChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactChangedEventArgs(::Windows::ApplicationModel::Contacts::ContactChangedEventArgs^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactChangedEventArgs^ UnwrapContactChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactChangedEventArgs(::Windows::ApplicationModel::Contacts::ContactChangedEventArgs^ 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>(ContactChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactChangedEventArgs^ UnwrapContactChangedEventArgs(Local<Value> value) {
     return ContactChangedEventArgs::Unwrap<ContactChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactChangedEventArgs(Local<Object> exports) {
    ContactChangedEventArgs::Init(exports);
  }

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

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


          
            Nan::SetPrototypeMethod(localRef, "findRawContactsAsync", FindRawContactsAsync);
            Nan::SetPrototypeMethod(localRef, "tryLinkContactsAsync", TryLinkContactsAsync);
            Nan::SetPrototypeMethod(localRef, "unlinkRawContactAsync", UnlinkRawContactAsync);
            Nan::SetPrototypeMethod(localRef, "trySetPreferredSourceForPictureAsync", TrySetPreferredSourceForPictureAsync);
            Nan::SetPrototypeMethod(localRef, "setRemoteIdentificationInformationAsync", SetRemoteIdentificationInformationAsync);
          



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



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

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

    private:

      AggregateContactManager(::Windows::ApplicationModel::Contacts::AggregateContactManager^ 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::ApplicationModel::Contacts::AggregateContactManager^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::AggregateContactManager^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Contacts::Contact^>^>^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::Contact^ arg0 = UnwrapContact(info[0]);
          
          op = wrapper->_instance->FindRawContactsAsync(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::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Contacts::Contact^>^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::AggregateContactManager^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::ApplicationModel::Contacts::Contact^>^ op;


      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info[1]))
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::Contact^ arg0 = UnwrapContact(info[0]);
          ::Windows::ApplicationModel::Contacts::Contact^ arg1 = UnwrapContact(info[1]);
          
          op = wrapper->_instance->TryLinkContactsAsync(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::ApplicationModel::Contacts::Contact^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::AggregateContactManager^>(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;
      }

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

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


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::Contact^ arg0 = UnwrapContact(info[0]);
          
          op = wrapper->_instance->UnlinkRawContactAsync(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 TrySetPreferredSourceForPictureAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::AggregateContactManager^>(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;
      }

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

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


      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info[1]))
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::Contact^ arg0 = UnwrapContact(info[0]);
          ::Windows::ApplicationModel::Contacts::Contact^ arg1 = UnwrapContact(info[1]);
          
          op = wrapper->_instance->TrySetPreferredSourceForPictureAsync(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<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 SetRemoteIdentificationInformationAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::AggregateContactManager^>(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;
      }

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

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


      if (info.Length() == 4
        && info[0]->IsString()
        && info[1]->IsString()
        && info[2]->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])));
          Platform::String^ arg2 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[2])));
          
          op = wrapper->_instance->SetRemoteIdentificationInformationAsync(arg0,arg1,arg2);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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


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

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






    private:
      ::Windows::ApplicationModel::Contacts::AggregateContactManager^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAggregateContactManager(::Windows::ApplicationModel::Contacts::AggregateContactManager^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::AggregateContactManager^ UnwrapAggregateContactManager(Local<Value> value);
  };

  Persistent<FunctionTemplate> AggregateContactManager::s_constructorTemplate;

  v8::Local<v8::Value> WrapAggregateContactManager(::Windows::ApplicationModel::Contacts::AggregateContactManager^ 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>(AggregateContactManager::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::AggregateContactManager^ UnwrapAggregateContactManager(Local<Value> value) {
     return AggregateContactManager::Unwrap<AggregateContactManager>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAggregateContactManager(Local<Object> exports) {
    AggregateContactManager::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "getContactReader", GetContactReader);
          

          
            Nan::SetPrototypeMethod(localRef, "saveAsync", SaveAsync);
            Nan::SetPrototypeMethod(localRef, "deleteAsync", DeleteAsync);
            Nan::SetPrototypeMethod(localRef, "getContactFromRemoteIdAsync", GetContactFromRemoteIdAsync);
            Nan::SetPrototypeMethod(localRef, "getMeContactAsync", GetMeContactAsync);
            Nan::SetPrototypeMethod(localRef, "saveContactAsync", SaveContactAsync);
            Nan::SetPrototypeMethod(localRef, "deleteContactAsync", DeleteContactAsync);
            Nan::SetPrototypeMethod(localRef, "getContactAsync", GetContactAsync);
            Nan::SetPrototypeMethod(localRef, "registerSyncManagerAsync", RegisterSyncManagerAsync);
          

          
          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>("supportsServerSearch").ToLocalChecked(), SupportsServerSearchGetter, SupportsServerSearchSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isHidden").ToLocalChecked(), IsHiddenGetter, IsHiddenSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("otherAppWriteAccess").ToLocalChecked(), OtherAppWriteAccessGetter, OtherAppWriteAccessSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("displayName").ToLocalChecked(), DisplayNameGetter, DisplayNameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("otherAppReadAccess").ToLocalChecked(), OtherAppReadAccessGetter, OtherAppReadAccessSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("changeTracker").ToLocalChecked(), ChangeTrackerGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("sourceDisplayName").ToLocalChecked(), SourceDisplayNameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("id").ToLocalChecked(), IdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("syncManager").ToLocalChecked(), SyncManagerGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("userDataAccountId").ToLocalChecked(), UserDataAccountIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("syncConstraints").ToLocalChecked(), SyncConstraintsGetter);

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



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

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

    private:

      ContactList(::Windows::ApplicationModel::Contacts::ContactList^ 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::ApplicationModel::Contacts::ContactList^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactList^>(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;
      }

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactList^>(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;
      }

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactList^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::ApplicationModel::Contacts::Contact^>^ 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->GetContactFromRemoteIdAsync(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::ApplicationModel::Contacts::Contact^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactList^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::ApplicationModel::Contacts::Contact^>^ op;


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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactList^>(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;
      }

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

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


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::Contact^ arg0 = UnwrapContact(info[0]);
          
          op = wrapper->_instance->SaveContactAsync(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 DeleteContactAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactList^>(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;
      }

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

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


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::Contact^ arg0 = UnwrapContact(info[0]);
          
          op = wrapper->_instance->DeleteContactAsync(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 GetContactAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactList^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::ApplicationModel::Contacts::Contact^>^ 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->GetContactAsync(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::ApplicationModel::Contacts::Contact^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactList^>(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;
      }

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactList^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::ContactReader^ result;
          result = wrapper->_instance->GetContactReader();
          info.GetReturnValue().Set(WrapContactReader(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactQueryOptions^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::ContactQueryOptions^ arg0 = UnwrapContactQueryOptions(info[0]);
          
          ::Windows::ApplicationModel::Contacts::ContactReader^ result;
          result = wrapper->_instance->GetContactReader(arg0);
          info.GetReturnValue().Set(WrapContactReader(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 SupportsServerSearchGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactList^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactList^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactList^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactList^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactList^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::ApplicationModel::Contacts::ContactListOtherAppWriteAccess result = wrapper->_instance->OtherAppWriteAccess;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void OtherAppWriteAccessSetter(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::ApplicationModel::Contacts::ContactList^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::ApplicationModel::Contacts::ContactListOtherAppWriteAccess winRtValue = static_cast<::Windows::ApplicationModel::Contacts::ContactListOtherAppWriteAccess>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactList^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactList^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactList^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::ApplicationModel::Contacts::ContactListOtherAppReadAccess result = wrapper->_instance->OtherAppReadAccess;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void OtherAppReadAccessSetter(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::ApplicationModel::Contacts::ContactList^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::ApplicationModel::Contacts::ContactListOtherAppReadAccess winRtValue = static_cast<::Windows::ApplicationModel::Contacts::ContactListOtherAppReadAccess>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactList^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::ApplicationModel::Contacts::ContactChangeTracker^ result = wrapper->_instance->ChangeTracker;
        info.GetReturnValue().Set(WrapContactChangeTracker(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SourceDisplayNameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactList^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactList^>(info.This())) {
        return;
      }

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactList^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::ApplicationModel::Contacts::ContactListSyncManager^ result = wrapper->_instance->SyncManager;
        info.GetReturnValue().Set(WrapContactListSyncManager(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void UserDataAccountIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactList^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactList^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^ result = wrapper->_instance->SyncConstraints;
        info.GetReturnValue().Set(WrapContactListSyncConstraints(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"contactChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactList^>(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;
        }
        ContactList *wrapper = ContactList::Unwrap<ContactList>(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->ContactChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::ApplicationModel::Contacts::ContactList^, ::Windows::ApplicationModel::Contacts::ContactChangedEventArgs^>(
            [callbackObjPtr](::Windows::ApplicationModel::Contacts::ContactList^ arg0, ::Windows::ApplicationModel::Contacts::ContactChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapContactList(arg0);
                  wrappedArg1 = WrapContactChangedEventArgs(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"contactChanged", 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"contactChanged", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactList^>(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;
          }
          ContactList *wrapper = ContactList::Unwrap<ContactList>(info.This());
          wrapper->_instance->ContactChanged::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::ApplicationModel::Contacts::ContactList^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactList(::Windows::ApplicationModel::Contacts::ContactList^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactList^ UnwrapContactList(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactList::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactList(::Windows::ApplicationModel::Contacts::ContactList^ 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>(ContactList::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactList^ UnwrapContactList(Local<Value> value) {
     return ContactList::Unwrap<ContactList>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactList(Local<Object> exports) {
    ContactList::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "getMatchingPropertiesWithMatchReason", GetMatchingPropertiesWithMatchReason);
          

          
            Nan::SetPrototypeMethod(localRef, "readBatchAsync", ReadBatchAsync);
          



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



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

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

    private:

      ContactReader(::Windows::ApplicationModel::Contacts::ContactReader^ 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::ApplicationModel::Contacts::ContactReader^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactReader^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::ApplicationModel::Contacts::ContactBatch^>^ op;


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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactReader^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::Contact^ arg0 = UnwrapContact(info[0]);
          
          ::Windows::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Contacts::ContactMatchReason^>^ result;
          result = wrapper->_instance->GetMatchingPropertiesWithMatchReason(arg0);
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::ApplicationModel::Contacts::ContactMatchReason^>::CreateVectorViewWrapper(result, 
            [](::Windows::ApplicationModel::Contacts::ContactMatchReason^ val) -> Local<Value> {
              return WrapContactMatchReason(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactMatchReason^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Contacts::ContactMatchReason^ {
              return UnwrapContactMatchReason(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;
      }
    }





    private:
      ::Windows::ApplicationModel::Contacts::ContactReader^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactReader(::Windows::ApplicationModel::Contacts::ContactReader^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactReader^ UnwrapContactReader(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactReader::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactReader(::Windows::ApplicationModel::Contacts::ContactReader^ 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>(ContactReader::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactReader^ UnwrapContactReader(Local<Value> value) {
     return ContactReader::Unwrap<ContactReader>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactReader(Local<Object> exports) {
    ContactReader::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("includeContactsFromHiddenLists").ToLocalChecked(), IncludeContactsFromHiddenListsGetter, IncludeContactsFromHiddenListsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("desiredOperations").ToLocalChecked(), DesiredOperationsGetter, DesiredOperationsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("desiredFields").ToLocalChecked(), DesiredFieldsGetter, DesiredFieldsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("annotationListIds").ToLocalChecked(), AnnotationListIdsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("contactListIds").ToLocalChecked(), ContactListIdsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("textSearch").ToLocalChecked(), TextSearchGetter);

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



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

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

    private:

      ContactQueryOptions(::Windows::ApplicationModel::Contacts::ContactQueryOptions^ 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::ApplicationModel::Contacts::ContactQueryOptions^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactQueryOptions^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactQueryOptions^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactQueryOptions^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::ApplicationModel::Contacts::ContactAnnotationOperations result = wrapper->_instance->DesiredOperations;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DesiredOperationsSetter(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::ApplicationModel::Contacts::ContactQueryOptions^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::ApplicationModel::Contacts::ContactAnnotationOperations winRtValue = static_cast<::Windows::ApplicationModel::Contacts::ContactAnnotationOperations>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactQueryOptions^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::ApplicationModel::Contacts::ContactQueryDesiredFields result = wrapper->_instance->DesiredFields;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DesiredFieldsSetter(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::ApplicationModel::Contacts::ContactQueryOptions^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::ApplicationModel::Contacts::ContactQueryDesiredFields winRtValue = static_cast<::Windows::ApplicationModel::Contacts::ContactQueryDesiredFields>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactQueryOptions^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactQueryOptions^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactQueryOptions^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::ApplicationModel::Contacts::ContactQueryTextSearch^ result = wrapper->_instance->TextSearch;
        info.GetReturnValue().Set(WrapContactQueryTextSearch(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::ApplicationModel::Contacts::ContactQueryOptions^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactQueryOptions(::Windows::ApplicationModel::Contacts::ContactQueryOptions^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactQueryOptions^ UnwrapContactQueryOptions(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactQueryOptions::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactQueryOptions(::Windows::ApplicationModel::Contacts::ContactQueryOptions^ 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>(ContactQueryOptions::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactQueryOptions^ UnwrapContactQueryOptions(Local<Value> value) {
     return ContactQueryOptions::Unwrap<ContactQueryOptions>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactQueryOptions(Local<Object> exports) {
    ContactQueryOptions::Init(exports);
  }

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

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


          
            Nan::SetPrototypeMethod(localRef, "syncAsync", SyncAsync);
          

          
          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, StatusSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("lastSuccessfulSyncTime").ToLocalChecked(), LastSuccessfulSyncTimeGetter, LastSuccessfulSyncTimeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("lastAttemptedSyncTime").ToLocalChecked(), LastAttemptedSyncTimeGetter, LastAttemptedSyncTimeSetter);

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



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

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

    private:

      ContactListSyncManager(::Windows::ApplicationModel::Contacts::ContactListSyncManager^ 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::ApplicationModel::Contacts::ContactListSyncManager^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncManager^>(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;
      }

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncManager^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncManager^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::ApplicationModel::Contacts::ContactListSyncStatus winRtValue = static_cast<::Windows::ApplicationModel::Contacts::ContactListSyncStatus>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncManager^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncManager^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Foundation::DateTime winRtValue = NodeRT::Utils::DateTimeFromJSDate(value);

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncManager^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncManager^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Foundation::DateTime winRtValue = NodeRT::Utils::DateTimeFromJSDate(value);

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


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

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

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

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

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


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapContactListSyncManager(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"syncStatusChanged", 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"syncStatusChanged", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncManager^>(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;
          }
          ContactListSyncManager *wrapper = ContactListSyncManager::Unwrap<ContactListSyncManager>(info.This());
          wrapper->_instance->SyncStatusChanged::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::ApplicationModel::Contacts::ContactListSyncManager^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactListSyncManager(::Windows::ApplicationModel::Contacts::ContactListSyncManager^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactListSyncManager^ UnwrapContactListSyncManager(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactListSyncManager::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactListSyncManager(::Windows::ApplicationModel::Contacts::ContactListSyncManager^ 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>(ContactListSyncManager::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactListSyncManager^ UnwrapContactListSyncManager(Local<Value> value) {
     return ContactListSyncManager::Unwrap<ContactListSyncManager>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactListSyncManager(Local<Object> exports) {
    ContactListSyncManager::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("canSyncDescriptions").ToLocalChecked(), CanSyncDescriptionsGetter, CanSyncDescriptionsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxCompanyPhoneNumbers").ToLocalChecked(), MaxCompanyPhoneNumbersGetter, MaxCompanyPhoneNumbersSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxChildRelationships").ToLocalChecked(), MaxChildRelationshipsGetter, MaxChildRelationshipsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxBusinessFaxPhoneNumbers").ToLocalChecked(), MaxBusinessFaxPhoneNumbersGetter, MaxBusinessFaxPhoneNumbersSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxBirthdayDates").ToLocalChecked(), MaxBirthdayDatesGetter, MaxBirthdayDatesSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxAssistantPhoneNumbers").ToLocalChecked(), MaxAssistantPhoneNumbersGetter, MaxAssistantPhoneNumbersSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxOtherAddresses").ToLocalChecked(), MaxOtherAddressesGetter, MaxOtherAddressesSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxAnniversaryDates").ToLocalChecked(), MaxAnniversaryDatesGetter, MaxAnniversaryDatesSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxHomeAddresses").ToLocalChecked(), MaxHomeAddressesGetter, MaxHomeAddressesSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxOtherDates").ToLocalChecked(), MaxOtherDatesGetter, MaxOtherDatesSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxMobilePhoneNumbers").ToLocalChecked(), MaxMobilePhoneNumbersGetter, MaxMobilePhoneNumbersSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxJobInfo").ToLocalChecked(), MaxJobInfoGetter, MaxJobInfoSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxHomePhoneNumbers").ToLocalChecked(), MaxHomePhoneNumbersGetter, MaxHomePhoneNumbersSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxHomeFaxPhoneNumbers").ToLocalChecked(), MaxHomeFaxPhoneNumbersGetter, MaxHomeFaxPhoneNumbersSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxOtherEmailAddresses").ToLocalChecked(), MaxOtherEmailAddressesGetter, MaxOtherEmailAddressesSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxPersonalEmailAddresses").ToLocalChecked(), MaxPersonalEmailAddressesGetter, MaxPersonalEmailAddressesSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxPartnerRelationships").ToLocalChecked(), MaxPartnerRelationshipsGetter, MaxPartnerRelationshipsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxParentRelationships").ToLocalChecked(), MaxParentRelationshipsGetter, MaxParentRelationshipsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxPagerPhoneNumbers").ToLocalChecked(), MaxPagerPhoneNumbersGetter, MaxPagerPhoneNumbersSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxOtherRelationships").ToLocalChecked(), MaxOtherRelationshipsGetter, MaxOtherRelationshipsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxOtherPhoneNumbers").ToLocalChecked(), MaxOtherPhoneNumbersGetter, MaxOtherPhoneNumbersSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxRadioPhoneNumbers").ToLocalChecked(), MaxRadioPhoneNumbersGetter, MaxRadioPhoneNumbersSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxWorkPhoneNumbers").ToLocalChecked(), MaxWorkPhoneNumbersGetter, MaxWorkPhoneNumbersSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxWorkEmailAddresses").ToLocalChecked(), MaxWorkEmailAddressesGetter, MaxWorkEmailAddressesSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxWorkAddresses").ToLocalChecked(), MaxWorkAddressesGetter, MaxWorkAddressesSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxWebsites").ToLocalChecked(), MaxWebsitesGetter, MaxWebsitesSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxSpouseRelationships").ToLocalChecked(), MaxSpouseRelationshipsGetter, MaxSpouseRelationshipsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxSiblingRelationships").ToLocalChecked(), MaxSiblingRelationshipsGetter, MaxSiblingRelationshipsSetter);

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



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

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

    private:

      ContactListSyncConstraints(::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^ 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::ApplicationModel::Contacts::ContactListSyncConstraints^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->MaxCompanyPhoneNumbers;
        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 MaxCompanyPhoneNumbersSetter(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::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<int>^ winRtValue = ref new ::Platform::Box<int>(static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->MaxChildRelationships;
        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 MaxChildRelationshipsSetter(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::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<int>^ winRtValue = ref new ::Platform::Box<int>(static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->MaxBusinessFaxPhoneNumbers;
        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 MaxBusinessFaxPhoneNumbersSetter(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::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<int>^ winRtValue = ref new ::Platform::Box<int>(static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->MaxBirthdayDates;
        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 MaxBirthdayDatesSetter(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::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<int>^ winRtValue = ref new ::Platform::Box<int>(static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->MaxAssistantPhoneNumbers;
        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 MaxAssistantPhoneNumbersSetter(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::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<int>^ winRtValue = ref new ::Platform::Box<int>(static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->MaxOtherAddresses;
        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 MaxOtherAddressesSetter(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::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<int>^ winRtValue = ref new ::Platform::Box<int>(static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->MaxAnniversaryDates;
        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 MaxAnniversaryDatesSetter(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::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<int>^ winRtValue = ref new ::Platform::Box<int>(static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->MaxHomeAddresses;
        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 MaxHomeAddressesSetter(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::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<int>^ winRtValue = ref new ::Platform::Box<int>(static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->MaxOtherDates;
        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 MaxOtherDatesSetter(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::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<int>^ winRtValue = ref new ::Platform::Box<int>(static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->MaxMobilePhoneNumbers;
        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 MaxMobilePhoneNumbersSetter(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::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<int>^ winRtValue = ref new ::Platform::Box<int>(static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->MaxJobInfo;
        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 MaxJobInfoSetter(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::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<int>^ winRtValue = ref new ::Platform::Box<int>(static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->MaxHomePhoneNumbers;
        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 MaxHomePhoneNumbersSetter(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::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<int>^ winRtValue = ref new ::Platform::Box<int>(static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->MaxHomeFaxPhoneNumbers;
        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 MaxHomeFaxPhoneNumbersSetter(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::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<int>^ winRtValue = ref new ::Platform::Box<int>(static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->MaxOtherEmailAddresses;
        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 MaxOtherEmailAddressesSetter(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::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<int>^ winRtValue = ref new ::Platform::Box<int>(static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->MaxPersonalEmailAddresses;
        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 MaxPersonalEmailAddressesSetter(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::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<int>^ winRtValue = ref new ::Platform::Box<int>(static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->MaxPartnerRelationships;
        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 MaxPartnerRelationshipsSetter(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::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<int>^ winRtValue = ref new ::Platform::Box<int>(static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->MaxParentRelationships;
        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 MaxParentRelationshipsSetter(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::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<int>^ winRtValue = ref new ::Platform::Box<int>(static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->MaxPagerPhoneNumbers;
        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 MaxPagerPhoneNumbersSetter(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::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<int>^ winRtValue = ref new ::Platform::Box<int>(static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->MaxOtherRelationships;
        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 MaxOtherRelationshipsSetter(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::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<int>^ winRtValue = ref new ::Platform::Box<int>(static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->MaxOtherPhoneNumbers;
        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 MaxOtherPhoneNumbersSetter(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::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<int>^ winRtValue = ref new ::Platform::Box<int>(static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->MaxRadioPhoneNumbers;
        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 MaxRadioPhoneNumbersSetter(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::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<int>^ winRtValue = ref new ::Platform::Box<int>(static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->MaxWorkPhoneNumbers;
        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 MaxWorkPhoneNumbersSetter(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::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<int>^ winRtValue = ref new ::Platform::Box<int>(static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->MaxWorkEmailAddresses;
        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 MaxWorkEmailAddressesSetter(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::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<int>^ winRtValue = ref new ::Platform::Box<int>(static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->MaxWorkAddresses;
        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 MaxWorkAddressesSetter(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::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<int>^ winRtValue = ref new ::Platform::Box<int>(static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->MaxWebsites;
        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 MaxWebsitesSetter(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::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<int>^ winRtValue = ref new ::Platform::Box<int>(static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->MaxSpouseRelationships;
        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 MaxSpouseRelationshipsSetter(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::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<int>^ winRtValue = ref new ::Platform::Box<int>(static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->MaxSiblingRelationships;
        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 MaxSiblingRelationshipsSetter(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::ApplicationModel::Contacts::ContactListSyncConstraints^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<int>^ winRtValue = ref new ::Platform::Box<int>(static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0)));

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


    private:
      ::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactListSyncConstraints(::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^ UnwrapContactListSyncConstraints(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactListSyncConstraints::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactListSyncConstraints(::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^ 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>(ContactListSyncConstraints::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactListSyncConstraints^ UnwrapContactListSyncConstraints(Local<Value> value) {
     return ContactListSyncConstraints::Unwrap<ContactListSyncConstraints>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactListSyncConstraints(Local<Object> exports) {
    ContactListSyncConstraints::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("category").ToLocalChecked(), CategoryGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("name").ToLocalChecked(), NameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("type").ToLocalChecked(), TypeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("value").ToLocalChecked(), ValueGetter);

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



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

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

    private:

      IContactField(::Windows::ApplicationModel::Contacts::IContactField^ 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::ApplicationModel::Contacts::IContactField^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::IContactField^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::IContactField^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::IContactField^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::IContactField^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::ApplicationModel::Contacts::IContactField^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIContactField(::Windows::ApplicationModel::Contacts::IContactField^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::IContactField^ UnwrapIContactField(Local<Value> value);
  };

  Persistent<FunctionTemplate> IContactField::s_constructorTemplate;

  v8::Local<v8::Value> WrapIContactField(::Windows::ApplicationModel::Contacts::IContactField^ 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>(IContactField::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::IContactField^ UnwrapIContactField(Local<Value> value) {
     return IContactField::Unwrap<IContactField>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIContactField(Local<Object> exports) {
    IContactField::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("number").ToLocalChecked(), NumberGetter, NumberSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter, KindSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("description").ToLocalChecked(), DescriptionGetter, DescriptionSetter);

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



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

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

    private:

      ContactPhone(::Windows::ApplicationModel::Contacts::ContactPhone^ 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::ApplicationModel::Contacts::ContactPhone^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactPhone^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactPhone^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::ApplicationModel::Contacts::ContactPhoneKind 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 KindSetter(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::ApplicationModel::Contacts::ContactPhone^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::ApplicationModel::Contacts::ContactPhoneKind winRtValue = static_cast<::Windows::ApplicationModel::Contacts::ContactPhoneKind>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactPhone^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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


    private:
      ::Windows::ApplicationModel::Contacts::ContactPhone^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactPhone(::Windows::ApplicationModel::Contacts::ContactPhone^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactPhone^ UnwrapContactPhone(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactPhone::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactPhone(::Windows::ApplicationModel::Contacts::ContactPhone^ 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>(ContactPhone::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactPhone^ UnwrapContactPhone(Local<Value> value) {
     return ContactPhone::Unwrap<ContactPhone>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactPhone(Local<Object> exports) {
    ContactPhone::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter, KindSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("description").ToLocalChecked(), DescriptionGetter, DescriptionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("address").ToLocalChecked(), AddressGetter, AddressSetter);

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



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

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

    private:

      ContactEmail(::Windows::ApplicationModel::Contacts::ContactEmail^ 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::ApplicationModel::Contacts::ContactEmail^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactEmail^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::ApplicationModel::Contacts::ContactEmailKind 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 KindSetter(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::ApplicationModel::Contacts::ContactEmail^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::ApplicationModel::Contacts::ContactEmailKind winRtValue = static_cast<::Windows::ApplicationModel::Contacts::ContactEmailKind>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactEmail^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactEmail^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactEmail^>(info.This())) {
        return;
      }

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

      try {

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

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


    private:
      ::Windows::ApplicationModel::Contacts::ContactEmail^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactEmail(::Windows::ApplicationModel::Contacts::ContactEmail^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactEmail^ UnwrapContactEmail(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactEmail::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactEmail(::Windows::ApplicationModel::Contacts::ContactEmail^ 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>(ContactEmail::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactEmail^ UnwrapContactEmail(Local<Value> value) {
     return ContactEmail::Unwrap<ContactEmail>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactEmail(Local<Object> exports) {
    ContactEmail::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("streetAddress").ToLocalChecked(), StreetAddressGetter, StreetAddressSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("region").ToLocalChecked(), RegionGetter, RegionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("postalCode").ToLocalChecked(), PostalCodeGetter, PostalCodeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("locality").ToLocalChecked(), LocalityGetter, LocalitySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter, KindSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("description").ToLocalChecked(), DescriptionGetter, DescriptionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("country").ToLocalChecked(), CountryGetter, CountrySetter);

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



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

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

    private:

      ContactAddress(::Windows::ApplicationModel::Contacts::ContactAddress^ 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::ApplicationModel::Contacts::ContactAddress^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAddress^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAddress^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAddress^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAddress^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAddress^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::ApplicationModel::Contacts::ContactAddressKind 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 KindSetter(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::ApplicationModel::Contacts::ContactAddress^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::ApplicationModel::Contacts::ContactAddressKind winRtValue = static_cast<::Windows::ApplicationModel::Contacts::ContactAddressKind>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAddress^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactAddress^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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


    private:
      ::Windows::ApplicationModel::Contacts::ContactAddress^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactAddress(::Windows::ApplicationModel::Contacts::ContactAddress^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactAddress^ UnwrapContactAddress(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactAddress::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactAddress(::Windows::ApplicationModel::Contacts::ContactAddress^ 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>(ContactAddress::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactAddress^ UnwrapContactAddress(Local<Value> value) {
     return ContactAddress::Unwrap<ContactAddress>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactAddress(Local<Object> exports) {
    ContactAddress::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("serviceName").ToLocalChecked(), ServiceNameGetter, ServiceNameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("id").ToLocalChecked(), IdGetter, IdSetter);

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



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

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

    private:

      ContactConnectedServiceAccount(::Windows::ApplicationModel::Contacts::ContactConnectedServiceAccount^ 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::ApplicationModel::Contacts::ContactConnectedServiceAccount^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactConnectedServiceAccount^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactConnectedServiceAccount^>(info.This())) {
        return;
      }

      ContactConnectedServiceAccount *wrapper = ContactConnectedServiceAccount::Unwrap<ContactConnectedServiceAccount>(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 IdSetter(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::ApplicationModel::Contacts::ContactConnectedServiceAccount^>(info.This())) {
        return;
      }

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

      try {

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

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


    private:
      ::Windows::ApplicationModel::Contacts::ContactConnectedServiceAccount^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactConnectedServiceAccount(::Windows::ApplicationModel::Contacts::ContactConnectedServiceAccount^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactConnectedServiceAccount^ UnwrapContactConnectedServiceAccount(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactConnectedServiceAccount::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactConnectedServiceAccount(::Windows::ApplicationModel::Contacts::ContactConnectedServiceAccount^ 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>(ContactConnectedServiceAccount::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactConnectedServiceAccount^ UnwrapContactConnectedServiceAccount(Local<Value> value) {
     return ContactConnectedServiceAccount::Unwrap<ContactConnectedServiceAccount>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactConnectedServiceAccount(Local<Object> exports) {
    ContactConnectedServiceAccount::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("year").ToLocalChecked(), YearGetter, YearSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("month").ToLocalChecked(), MonthGetter, MonthSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter, KindSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("description").ToLocalChecked(), DescriptionGetter, DescriptionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("day").ToLocalChecked(), DayGetter, DaySetter);

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



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

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

    private:

      ContactDate(::Windows::ApplicationModel::Contacts::ContactDate^ 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::ApplicationModel::Contacts::ContactDate^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactDate^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<int>^ result = wrapper->_instance->Year;
        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 YearSetter(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::ApplicationModel::Contacts::ContactDate^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<int>^ winRtValue = ref new ::Platform::Box<int>(static_cast<int>(Nan::To<int32_t>(value).FromMaybe(0)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactDate^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<unsigned int>^ result = wrapper->_instance->Month;
        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 MonthSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactDate^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<unsigned int>^ winRtValue = ref new ::Platform::Box<unsigned int>(static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0)));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactDate^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::ApplicationModel::Contacts::ContactDateKind 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 KindSetter(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::ApplicationModel::Contacts::ContactDate^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::ApplicationModel::Contacts::ContactDateKind winRtValue = static_cast<::Windows::ApplicationModel::Contacts::ContactDateKind>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactDate^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactDate^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<unsigned int>^ result = wrapper->_instance->Day;
        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 DaySetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactDate^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<unsigned int>^ winRtValue = ref new ::Platform::Box<unsigned int>(static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0)));

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


    private:
      ::Windows::ApplicationModel::Contacts::ContactDate^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactDate(::Windows::ApplicationModel::Contacts::ContactDate^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactDate^ UnwrapContactDate(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactDate::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactDate(::Windows::ApplicationModel::Contacts::ContactDate^ 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>(ContactDate::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactDate^ UnwrapContactDate(Local<Value> value) {
     return ContactDate::Unwrap<ContactDate>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactDate(Local<Object> exports) {
    ContactDate::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("title").ToLocalChecked(), TitleGetter, TitleSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("office").ToLocalChecked(), OfficeGetter, OfficeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("manager").ToLocalChecked(), ManagerGetter, ManagerSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("description").ToLocalChecked(), DescriptionGetter, DescriptionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("department").ToLocalChecked(), DepartmentGetter, DepartmentSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("companyYomiName").ToLocalChecked(), CompanyYomiNameGetter, CompanyYomiNameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("companyName").ToLocalChecked(), CompanyNameGetter, CompanyNameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("companyAddress").ToLocalChecked(), CompanyAddressGetter, CompanyAddressSetter);

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



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

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

    private:

      ContactJobInfo(::Windows::ApplicationModel::Contacts::ContactJobInfo^ 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::ApplicationModel::Contacts::ContactJobInfo^ winRtInstance;


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

      ContactJobInfo *wrapperInstance = new ContactJobInfo(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::ApplicationModel::Contacts::ContactJobInfo^>(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::ApplicationModel::Contacts::ContactJobInfo^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Contacts::ContactJobInfo^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapContactJobInfo(winRtInstance));
    }





    static void TitleGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactJobInfo^>(info.This())) {
        return;
      }

      ContactJobInfo *wrapper = ContactJobInfo::Unwrap<ContactJobInfo>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Title;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TitleSetter(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::ApplicationModel::Contacts::ContactJobInfo^>(info.This())) {
        return;
      }

      ContactJobInfo *wrapper = ContactJobInfo::Unwrap<ContactJobInfo>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->Title = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void OfficeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactJobInfo^>(info.This())) {
        return;
      }

      ContactJobInfo *wrapper = ContactJobInfo::Unwrap<ContactJobInfo>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Office;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void OfficeSetter(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::ApplicationModel::Contacts::ContactJobInfo^>(info.This())) {
        return;
      }

      ContactJobInfo *wrapper = ContactJobInfo::Unwrap<ContactJobInfo>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->Office = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ManagerGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactJobInfo^>(info.This())) {
        return;
      }

      ContactJobInfo *wrapper = ContactJobInfo::Unwrap<ContactJobInfo>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Manager;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ManagerSetter(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::ApplicationModel::Contacts::ContactJobInfo^>(info.This())) {
        return;
      }

      ContactJobInfo *wrapper = ContactJobInfo::Unwrap<ContactJobInfo>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->Manager = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void DescriptionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactJobInfo^>(info.This())) {
        return;
      }

      ContactJobInfo *wrapper = ContactJobInfo::Unwrap<ContactJobInfo>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Description;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DescriptionSetter(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::ApplicationModel::Contacts::ContactJobInfo^>(info.This())) {
        return;
      }

      ContactJobInfo *wrapper = ContactJobInfo::Unwrap<ContactJobInfo>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->Description = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void DepartmentGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactJobInfo^>(info.This())) {
        return;
      }

      ContactJobInfo *wrapper = ContactJobInfo::Unwrap<ContactJobInfo>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Department;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DepartmentSetter(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::ApplicationModel::Contacts::ContactJobInfo^>(info.This())) {
        return;
      }

      ContactJobInfo *wrapper = ContactJobInfo::Unwrap<ContactJobInfo>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->Department = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void CompanyYomiNameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactJobInfo^>(info.This())) {
        return;
      }

      ContactJobInfo *wrapper = ContactJobInfo::Unwrap<ContactJobInfo>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->CompanyYomiName;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CompanyYomiNameSetter(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::ApplicationModel::Contacts::ContactJobInfo^>(info.This())) {
        return;
      }

      ContactJobInfo *wrapper = ContactJobInfo::Unwrap<ContactJobInfo>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->CompanyYomiName = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void CompanyNameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactJobInfo^>(info.This())) {
        return;
      }

      ContactJobInfo *wrapper = ContactJobInfo::Unwrap<ContactJobInfo>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->CompanyName;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CompanyNameSetter(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::ApplicationModel::Contacts::ContactJobInfo^>(info.This())) {
        return;
      }

      ContactJobInfo *wrapper = ContactJobInfo::Unwrap<ContactJobInfo>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->CompanyName = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void CompanyAddressGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactJobInfo^>(info.This())) {
        return;
      }

      ContactJobInfo *wrapper = ContactJobInfo::Unwrap<ContactJobInfo>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->CompanyAddress;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CompanyAddressSetter(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::ApplicationModel::Contacts::ContactJobInfo^>(info.This())) {
        return;
      }

      ContactJobInfo *wrapper = ContactJobInfo::Unwrap<ContactJobInfo>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->CompanyAddress = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      


    private:
      ::Windows::ApplicationModel::Contacts::ContactJobInfo^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactJobInfo(::Windows::ApplicationModel::Contacts::ContactJobInfo^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactJobInfo^ UnwrapContactJobInfo(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactJobInfo::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactJobInfo(::Windows::ApplicationModel::Contacts::ContactJobInfo^ 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>(ContactJobInfo::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactJobInfo^ UnwrapContactJobInfo(Local<Value> value) {
     return ContactJobInfo::Unwrap<ContactJobInfo>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactJobInfo(Local<Object> exports) {
    ContactJobInfo::Init(exports);
  }

  class ContactSignificantOther : 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>("ContactSignificantOther").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("name").ToLocalChecked(), NameGetter, NameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("description").ToLocalChecked(), DescriptionGetter, DescriptionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("relationship").ToLocalChecked(), RelationshipGetter, RelationshipSetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ContactSignificantOther").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ContactSignificantOther(::Windows::ApplicationModel::Contacts::ContactSignificantOther^ 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::ApplicationModel::Contacts::ContactSignificantOther^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactSignificantOther^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Contacts::ContactSignificantOther^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::ApplicationModel::Contacts::ContactSignificantOther();
        } 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());

      ContactSignificantOther *wrapperInstance = new ContactSignificantOther(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::ApplicationModel::Contacts::ContactSignificantOther^>(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::ApplicationModel::Contacts::ContactSignificantOther^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Contacts::ContactSignificantOther^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapContactSignificantOther(winRtInstance));
    }





    static void NameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactSignificantOther^>(info.This())) {
        return;
      }

      ContactSignificantOther *wrapper = ContactSignificantOther::Unwrap<ContactSignificantOther>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Name;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void NameSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsString()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactSignificantOther^>(info.This())) {
        return;
      }

      ContactSignificantOther *wrapper = ContactSignificantOther::Unwrap<ContactSignificantOther>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->Name = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void DescriptionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactSignificantOther^>(info.This())) {
        return;
      }

      ContactSignificantOther *wrapper = ContactSignificantOther::Unwrap<ContactSignificantOther>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Description;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DescriptionSetter(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::ApplicationModel::Contacts::ContactSignificantOther^>(info.This())) {
        return;
      }

      ContactSignificantOther *wrapper = ContactSignificantOther::Unwrap<ContactSignificantOther>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->Description = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void RelationshipGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactSignificantOther^>(info.This())) {
        return;
      }

      ContactSignificantOther *wrapper = ContactSignificantOther::Unwrap<ContactSignificantOther>(info.This());

      try  {
        ::Windows::ApplicationModel::Contacts::ContactRelationship result = wrapper->_instance->Relationship;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RelationshipSetter(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::ApplicationModel::Contacts::ContactSignificantOther^>(info.This())) {
        return;
      }

      ContactSignificantOther *wrapper = ContactSignificantOther::Unwrap<ContactSignificantOther>(info.This());

      try {

        ::Windows::ApplicationModel::Contacts::ContactRelationship winRtValue = static_cast<::Windows::ApplicationModel::Contacts::ContactRelationship>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->Relationship = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      


    private:
      ::Windows::ApplicationModel::Contacts::ContactSignificantOther^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactSignificantOther(::Windows::ApplicationModel::Contacts::ContactSignificantOther^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactSignificantOther^ UnwrapContactSignificantOther(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactSignificantOther::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactSignificantOther(::Windows::ApplicationModel::Contacts::ContactSignificantOther^ 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>(ContactSignificantOther::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactSignificantOther^ UnwrapContactSignificantOther(Local<Value> value) {
     return ContactSignificantOther::Unwrap<ContactSignificantOther>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactSignificantOther(Local<Object> exports) {
    ContactSignificantOther::Init(exports);
  }

  class ContactWebsite : 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>("ContactWebsite").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("uri").ToLocalChecked(), UriGetter, UriSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("description").ToLocalChecked(), DescriptionGetter, DescriptionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("rawValue").ToLocalChecked(), RawValueGetter, RawValueSetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ContactWebsite").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ContactWebsite(::Windows::ApplicationModel::Contacts::ContactWebsite^ 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::ApplicationModel::Contacts::ContactWebsite^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactWebsite^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Contacts::ContactWebsite^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::ApplicationModel::Contacts::ContactWebsite();
        } 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());

      ContactWebsite *wrapperInstance = new ContactWebsite(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::ApplicationModel::Contacts::ContactWebsite^>(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::ApplicationModel::Contacts::ContactWebsite^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Contacts::ContactWebsite^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapContactWebsite(winRtInstance));
    }





    static void UriGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactWebsite^>(info.This())) {
        return;
      }

      ContactWebsite *wrapper = ContactWebsite::Unwrap<ContactWebsite>(info.This());

      try  {
        ::Windows::Foundation::Uri^ result = wrapper->_instance->Uri;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "Uri", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void UriSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactWebsite^>(info.This())) {
        return;
      }

      ContactWebsite *wrapper = ContactWebsite::Unwrap<ContactWebsite>(info.This());

      try {

        ::Windows::Foundation::Uri^ winRtValue = dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->Uri = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void DescriptionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactWebsite^>(info.This())) {
        return;
      }

      ContactWebsite *wrapper = ContactWebsite::Unwrap<ContactWebsite>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Description;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DescriptionSetter(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::ApplicationModel::Contacts::ContactWebsite^>(info.This())) {
        return;
      }

      ContactWebsite *wrapper = ContactWebsite::Unwrap<ContactWebsite>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->Description = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void RawValueGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactWebsite^>(info.This())) {
        return;
      }

      ContactWebsite *wrapper = ContactWebsite::Unwrap<ContactWebsite>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->RawValue;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RawValueSetter(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::ApplicationModel::Contacts::ContactWebsite^>(info.This())) {
        return;
      }

      ContactWebsite *wrapper = ContactWebsite::Unwrap<ContactWebsite>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->RawValue = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      


    private:
      ::Windows::ApplicationModel::Contacts::ContactWebsite^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactWebsite(::Windows::ApplicationModel::Contacts::ContactWebsite^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactWebsite^ UnwrapContactWebsite(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactWebsite::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactWebsite(::Windows::ApplicationModel::Contacts::ContactWebsite^ 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>(ContactWebsite::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactWebsite^ UnwrapContactWebsite(Local<Value> value) {
     return ContactWebsite::Unwrap<ContactWebsite>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactWebsite(Local<Object> exports) {
    ContactWebsite::Init(exports);
  }

  class ContactChangedDeferral : 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>("ContactChangedDeferral").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "complete", Complete);
          




        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ContactChangedDeferral").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ContactChangedDeferral(::Windows::ApplicationModel::Contacts::ContactChangedDeferral^ 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::ApplicationModel::Contacts::ContactChangedDeferral^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactChangedDeferral^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Contacts::ContactChangedDeferral^) 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());

      ContactChangedDeferral *wrapperInstance = new ContactChangedDeferral(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::ApplicationModel::Contacts::ContactChangedDeferral^>(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::ApplicationModel::Contacts::ContactChangedDeferral^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Contacts::ContactChangedDeferral^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapContactChangedDeferral(winRtInstance));
    }


    static void Complete(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactChangedDeferral^>(info.This())) {
        return;
      }

      ContactChangedDeferral *wrapper = ContactChangedDeferral::Unwrap<ContactChangedDeferral>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->Complete();
          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::ApplicationModel::Contacts::ContactChangedDeferral^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactChangedDeferral(::Windows::ApplicationModel::Contacts::ContactChangedDeferral^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactChangedDeferral^ UnwrapContactChangedDeferral(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactChangedDeferral::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactChangedDeferral(::Windows::ApplicationModel::Contacts::ContactChangedDeferral^ 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>(ContactChangedDeferral::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactChangedDeferral^ UnwrapContactChangedDeferral(Local<Value> value) {
     return ContactChangedDeferral::Unwrap<ContactChangedDeferral>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactChangedDeferral(Local<Object> exports) {
    ContactChangedDeferral::Init(exports);
  }

  class ContactChange : 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>("ContactChange").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("changeType").ToLocalChecked(), ChangeTypeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("contact").ToLocalChecked(), ContactGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ContactChange").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ContactChange(::Windows::ApplicationModel::Contacts::ContactChange^ 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::ApplicationModel::Contacts::ContactChange^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactChange^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Contacts::ContactChange^) 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());

      ContactChange *wrapperInstance = new ContactChange(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::ApplicationModel::Contacts::ContactChange^>(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::ApplicationModel::Contacts::ContactChange^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Contacts::ContactChange^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapContactChange(winRtInstance));
    }





    static void ChangeTypeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactChange^>(info.This())) {
        return;
      }

      ContactChange *wrapper = ContactChange::Unwrap<ContactChange>(info.This());

      try  {
        ::Windows::ApplicationModel::Contacts::ContactChangeType result = wrapper->_instance->ChangeType;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ContactGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactChange^>(info.This())) {
        return;
      }

      ContactChange *wrapper = ContactChange::Unwrap<ContactChange>(info.This());

      try  {
        ::Windows::ApplicationModel::Contacts::Contact^ result = wrapper->_instance->Contact;
        info.GetReturnValue().Set(WrapContact(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::ApplicationModel::Contacts::ContactChange^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactChange(::Windows::ApplicationModel::Contacts::ContactChange^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactChange^ UnwrapContactChange(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactChange::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactChange(::Windows::ApplicationModel::Contacts::ContactChange^ 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>(ContactChange::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactChange^ UnwrapContactChange(Local<Value> value) {
     return ContactChange::Unwrap<ContactChange>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactChange(Local<Object> exports) {
    ContactChange::Init(exports);
  }

  class ContactChangeReader : 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>("ContactChangeReader").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);

        Local<Function> func;
        Local<FunctionTemplate> funcTemplate;

          
            Nan::SetPrototypeMethod(localRef, "acceptChanges", AcceptChanges);
            Nan::SetPrototypeMethod(localRef, "acceptChangesThrough", AcceptChangesThrough);
          

          
            Nan::SetPrototypeMethod(localRef, "readBatchAsync", ReadBatchAsync);
          



        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ContactChangeReader").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ContactChangeReader(::Windows::ApplicationModel::Contacts::ContactChangeReader^ 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::ApplicationModel::Contacts::ContactChangeReader^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactChangeReader^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Contacts::ContactChangeReader^) 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());

      ContactChangeReader *wrapperInstance = new ContactChangeReader(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::ApplicationModel::Contacts::ContactChangeReader^>(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::ApplicationModel::Contacts::ContactChangeReader^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Contacts::ContactChangeReader^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapContactChangeReader(winRtInstance));
    }

    static void ReadBatchAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactChangeReader^>(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;
      }

      ContactChangeReader *wrapper = ContactChangeReader::Unwrap<ContactChangeReader>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Contacts::ContactChange^>^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->ReadBatchAsync();
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

      auto opTask = create_task(op);
      uv_async_t* asyncToken = NodeUtils::Async::GetAsyncToken(info[info.Length() -1].As<Function>());

      opTask.then( [asyncToken] (task<::Windows::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Contacts::ContactChange^>^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = NodeRT::Collections::VectorViewWrapper<::Windows::ApplicationModel::Contacts::ContactChange^>::CreateVectorViewWrapper(result, 
            [](::Windows::ApplicationModel::Contacts::ContactChange^ val) -> Local<Value> {
              return WrapContactChange(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactChange^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Contacts::ContactChange^ {
              return UnwrapContactChange(value);
            }
          );
              if (tryCatch.HasCaught())
              {
                error = Nan::To<Object>(tryCatch.Exception()).ToLocalChecked();
              }
              else
              {
                error = Undefined();
              }
              if (arg1.IsEmpty()) arg1 = Undefined();
            }
            Local<Value> args[] = {error, arg1};


            invokeCallback(_countof(args), args);
          });
        } catch (Platform::Exception^ exception) {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {
            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

            Local<Value> args[] = {error};
            invokeCallback(_countof(args), args);
          });
        }
      });
    }

    static void AcceptChanges(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactChangeReader^>(info.This())) {
        return;
      }

      ContactChangeReader *wrapper = ContactChangeReader::Unwrap<ContactChangeReader>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->AcceptChanges();
          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 AcceptChangesThrough(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactChangeReader^>(info.This())) {
        return;
      }

      ContactChangeReader *wrapper = ContactChangeReader::Unwrap<ContactChangeReader>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactChange^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::ContactChange^ arg0 = UnwrapContactChange(info[0]);
          
          wrapper->_instance->AcceptChangesThrough(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::ApplicationModel::Contacts::ContactChangeReader^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactChangeReader(::Windows::ApplicationModel::Contacts::ContactChangeReader^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactChangeReader^ UnwrapContactChangeReader(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactChangeReader::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactChangeReader(::Windows::ApplicationModel::Contacts::ContactChangeReader^ 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>(ContactChangeReader::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactChangeReader^ UnwrapContactChangeReader(Local<Value> value) {
     return ContactChangeReader::Unwrap<ContactChangeReader>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactChangeReader(Local<Object> exports) {
    ContactChangeReader::Init(exports);
  }

  class ContactBatch : 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>("ContactBatch").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("contacts").ToLocalChecked(), ContactsGetter);
            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>("ContactBatch").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ContactBatch(::Windows::ApplicationModel::Contacts::ContactBatch^ 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::ApplicationModel::Contacts::ContactBatch^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactBatch^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Contacts::ContactBatch^) 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());

      ContactBatch *wrapperInstance = new ContactBatch(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::ApplicationModel::Contacts::ContactBatch^>(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::ApplicationModel::Contacts::ContactBatch^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Contacts::ContactBatch^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapContactBatch(winRtInstance));
    }





    static void ContactsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactBatch^>(info.This())) {
        return;
      }

      ContactBatch *wrapper = ContactBatch::Unwrap<ContactBatch>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Contacts::Contact^>^ result = wrapper->_instance->Contacts;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::ApplicationModel::Contacts::Contact^>::CreateVectorViewWrapper(result, 
            [](::Windows::ApplicationModel::Contacts::Contact^ val) -> Local<Value> {
              return WrapContact(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Contacts::Contact^ {
              return UnwrapContact(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void StatusGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactBatch^>(info.This())) {
        return;
      }

      ContactBatch *wrapper = ContactBatch::Unwrap<ContactBatch>(info.This());

      try  {
        ::Windows::ApplicationModel::Contacts::ContactBatchStatus 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::ApplicationModel::Contacts::ContactBatch^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactBatch(::Windows::ApplicationModel::Contacts::ContactBatch^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactBatch^ UnwrapContactBatch(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactBatch::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactBatch(::Windows::ApplicationModel::Contacts::ContactBatch^ 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>(ContactBatch::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactBatch^ UnwrapContactBatch(Local<Value> value) {
     return ContactBatch::Unwrap<ContactBatch>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactBatch(Local<Object> exports) {
    ContactBatch::Init(exports);
  }

  class ContactMatchReason : 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>("ContactMatchReason").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("field").ToLocalChecked(), FieldGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("segments").ToLocalChecked(), SegmentsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("text").ToLocalChecked(), TextGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ContactMatchReason").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ContactMatchReason(::Windows::ApplicationModel::Contacts::ContactMatchReason^ 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::ApplicationModel::Contacts::ContactMatchReason^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactMatchReason^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Contacts::ContactMatchReason^) 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());

      ContactMatchReason *wrapperInstance = new ContactMatchReason(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::ApplicationModel::Contacts::ContactMatchReason^>(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::ApplicationModel::Contacts::ContactMatchReason^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Contacts::ContactMatchReason^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapContactMatchReason(winRtInstance));
    }





    static void FieldGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactMatchReason^>(info.This())) {
        return;
      }

      ContactMatchReason *wrapper = ContactMatchReason::Unwrap<ContactMatchReason>(info.This());

      try  {
        ::Windows::ApplicationModel::Contacts::ContactMatchReasonKind result = wrapper->_instance->Field;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SegmentsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactMatchReason^>(info.This())) {
        return;
      }

      ContactMatchReason *wrapper = ContactMatchReason::Unwrap<ContactMatchReason>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Data::Text::TextSegment>^ result = wrapper->_instance->Segments;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Data::Text::TextSegment>::CreateVectorViewWrapper(result, 
            [](::Windows::Data::Text::TextSegment val) -> Local<Value> {
              return TextSegmentToJsObject(val);
            },
            [](Local<Value> value) -> bool {
              return IsTextSegmentJsObject(value);
            },
            [](Local<Value> value) -> ::Windows::Data::Text::TextSegment {
              return TextSegmentFromJsObject(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TextGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactMatchReason^>(info.This())) {
        return;
      }

      ContactMatchReason *wrapper = ContactMatchReason::Unwrap<ContactMatchReason>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Text;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::ApplicationModel::Contacts::ContactMatchReason^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactMatchReason(::Windows::ApplicationModel::Contacts::ContactMatchReason^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactMatchReason^ UnwrapContactMatchReason(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactMatchReason::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactMatchReason(::Windows::ApplicationModel::Contacts::ContactMatchReason^ 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>(ContactMatchReason::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactMatchReason^ UnwrapContactMatchReason(Local<Value> value) {
     return ContactMatchReason::Unwrap<ContactMatchReason>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactMatchReason(Local<Object> exports) {
    ContactMatchReason::Init(exports);
  }

  class ContactQueryTextSearch : 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>("ContactQueryTextSearch").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("text").ToLocalChecked(), TextGetter, TextSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("searchScope").ToLocalChecked(), SearchScopeGetter, SearchScopeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("fields").ToLocalChecked(), FieldsGetter, FieldsSetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ContactQueryTextSearch").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ContactQueryTextSearch(::Windows::ApplicationModel::Contacts::ContactQueryTextSearch^ 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::ApplicationModel::Contacts::ContactQueryTextSearch^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactQueryTextSearch^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Contacts::ContactQueryTextSearch^) 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());

      ContactQueryTextSearch *wrapperInstance = new ContactQueryTextSearch(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::ApplicationModel::Contacts::ContactQueryTextSearch^>(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::ApplicationModel::Contacts::ContactQueryTextSearch^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Contacts::ContactQueryTextSearch^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapContactQueryTextSearch(winRtInstance));
    }





    static void TextGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactQueryTextSearch^>(info.This())) {
        return;
      }

      ContactQueryTextSearch *wrapper = ContactQueryTextSearch::Unwrap<ContactQueryTextSearch>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Text;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TextSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsString()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactQueryTextSearch^>(info.This())) {
        return;
      }

      ContactQueryTextSearch *wrapper = ContactQueryTextSearch::Unwrap<ContactQueryTextSearch>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->Text = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void SearchScopeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactQueryTextSearch^>(info.This())) {
        return;
      }

      ContactQueryTextSearch *wrapper = ContactQueryTextSearch::Unwrap<ContactQueryTextSearch>(info.This());

      try  {
        ::Windows::ApplicationModel::Contacts::ContactQuerySearchScope result = wrapper->_instance->SearchScope;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SearchScopeSetter(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::ApplicationModel::Contacts::ContactQueryTextSearch^>(info.This())) {
        return;
      }

      ContactQueryTextSearch *wrapper = ContactQueryTextSearch::Unwrap<ContactQueryTextSearch>(info.This());

      try {

        ::Windows::ApplicationModel::Contacts::ContactQuerySearchScope winRtValue = static_cast<::Windows::ApplicationModel::Contacts::ContactQuerySearchScope>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->SearchScope = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void FieldsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactQueryTextSearch^>(info.This())) {
        return;
      }

      ContactQueryTextSearch *wrapper = ContactQueryTextSearch::Unwrap<ContactQueryTextSearch>(info.This());

      try  {
        ::Windows::ApplicationModel::Contacts::ContactQuerySearchFields result = wrapper->_instance->Fields;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void FieldsSetter(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::ApplicationModel::Contacts::ContactQueryTextSearch^>(info.This())) {
        return;
      }

      ContactQueryTextSearch *wrapper = ContactQueryTextSearch::Unwrap<ContactQueryTextSearch>(info.This());

      try {

        ::Windows::ApplicationModel::Contacts::ContactQuerySearchFields winRtValue = static_cast<::Windows::ApplicationModel::Contacts::ContactQuerySearchFields>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->Fields = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      


    private:
      ::Windows::ApplicationModel::Contacts::ContactQueryTextSearch^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactQueryTextSearch(::Windows::ApplicationModel::Contacts::ContactQueryTextSearch^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactQueryTextSearch^ UnwrapContactQueryTextSearch(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactQueryTextSearch::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactQueryTextSearch(::Windows::ApplicationModel::Contacts::ContactQueryTextSearch^ 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>(ContactQueryTextSearch::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactQueryTextSearch^ UnwrapContactQueryTextSearch(Local<Value> value) {
     return ContactQueryTextSearch::Unwrap<ContactQueryTextSearch>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactQueryTextSearch(Local<Object> exports) {
    ContactQueryTextSearch::Init(exports);
  }

  class ContactStoreNotificationTriggerDetails : 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>("ContactStoreNotificationTriggerDetails").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);






        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ContactStoreNotificationTriggerDetails").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ContactStoreNotificationTriggerDetails(::Windows::ApplicationModel::Contacts::ContactStoreNotificationTriggerDetails^ 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::ApplicationModel::Contacts::ContactStoreNotificationTriggerDetails^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactStoreNotificationTriggerDetails^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Contacts::ContactStoreNotificationTriggerDetails^) 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());

      ContactStoreNotificationTriggerDetails *wrapperInstance = new ContactStoreNotificationTriggerDetails(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::ApplicationModel::Contacts::ContactStoreNotificationTriggerDetails^>(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::ApplicationModel::Contacts::ContactStoreNotificationTriggerDetails^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Contacts::ContactStoreNotificationTriggerDetails^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapContactStoreNotificationTriggerDetails(winRtInstance));
    }







    private:
      ::Windows::ApplicationModel::Contacts::ContactStoreNotificationTriggerDetails^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactStoreNotificationTriggerDetails(::Windows::ApplicationModel::Contacts::ContactStoreNotificationTriggerDetails^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactStoreNotificationTriggerDetails^ UnwrapContactStoreNotificationTriggerDetails(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactStoreNotificationTriggerDetails::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactStoreNotificationTriggerDetails(::Windows::ApplicationModel::Contacts::ContactStoreNotificationTriggerDetails^ 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>(ContactStoreNotificationTriggerDetails::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactStoreNotificationTriggerDetails^ UnwrapContactStoreNotificationTriggerDetails(Local<Value> value) {
     return ContactStoreNotificationTriggerDetails::Unwrap<ContactStoreNotificationTriggerDetails>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactStoreNotificationTriggerDetails(Local<Object> exports) {
    ContactStoreNotificationTriggerDetails::Init(exports);
  }

  class ContactManager : 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>("ContactManager").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);

        Nan::SetMethod(constructor, "getForUser", GetForUser);
        Nan::SetMethod(constructor, "isShowContactCardSupported", IsShowContactCardSupported);
        Nan::SetMethod(constructor, "showContactCard", ShowContactCard);
        Nan::SetMethod(constructor, "isShowDelayLoadedContactCardSupported", IsShowDelayLoadedContactCardSupported);
        Nan::SetMethod(constructor, "showDelayLoadedContactCard", ShowDelayLoadedContactCard);
        Nan::SetMethod(constructor, "showFullContactCard", ShowFullContactCard);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(ConvertContactToVCardAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("convertContactToVCardAsync").ToLocalChecked(), func);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(ConvertVCardToContactAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("convertVCardToContactAsync").ToLocalChecked(), func);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(RequestStoreAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("requestStoreAsync").ToLocalChecked(), func);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(RequestAnnotationStoreAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("requestAnnotationStoreAsync").ToLocalChecked(), func);
        Nan::SetAccessor(constructor, Nan::New<String>("systemSortOrder").ToLocalChecked(), SystemSortOrderGetter, SystemSortOrderSetter);
        Nan::SetAccessor(constructor, Nan::New<String>("systemDisplayNameOrder").ToLocalChecked(), SystemDisplayNameOrderGetter, SystemDisplayNameOrderSetter);


        Nan::Set(exports, Nan::New<String>("ContactManager").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ContactManager(::Windows::ApplicationModel::Contacts::ContactManager^ 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::ApplicationModel::Contacts::ContactManager^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactManager^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Contacts::ContactManager^) 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());

      ContactManager *wrapperInstance = new ContactManager(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::ApplicationModel::Contacts::ContactManager^>(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::ApplicationModel::Contacts::ContactManager^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Contacts::ContactManager^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapContactManager(winRtInstance));
    }




    static void ConvertContactToVCardAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0 || !info[info.Length() -1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: No callback was given")));
        return;
      }

      ::Windows::Foundation::IAsyncOperation<::Windows::Storage::Streams::RandomAccessStreamReference^>^ op;


      if (info.Length() == 2
          && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::Contact^ arg0 = UnwrapContact(info[0]);
            
          op = ::Windows::ApplicationModel::Contacts::ContactManager::ConvertContactToVCardAsync(arg0);
        } catch (Platform::Exception ^exception) {
            NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
            return;
        }
      }
      else if (info.Length() == 3
          && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info[0])
          && info[1]->IsUint32())
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::Contact^ arg0 = UnwrapContact(info[0]);
          unsigned int arg1 = static_cast<unsigned int>(Nan::To<uint32_t>(info[1]).FromMaybe(0));
            
          op = ::Windows::ApplicationModel::Contacts::ContactManager::ConvertContactToVCardAsync(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::Storage::Streams::RandomAccessStreamReference^> t)
      {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.Storage.Streams", "RandomAccessStreamReference", 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 ConvertVCardToContactAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0 || !info[info.Length() -1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: No callback was given")));
        return;
      }

      ::Windows::Foundation::IAsyncOperation<::Windows::ApplicationModel::Contacts::Contact^>^ op;


      if (info.Length() == 2
          && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IRandomAccessStreamReference^>(info[0]))
      {
        try
        {
          ::Windows::Storage::Streams::IRandomAccessStreamReference^ arg0 = dynamic_cast<::Windows::Storage::Streams::IRandomAccessStreamReference^>(NodeRT::Utils::GetObjectInstance(info[0]));
            
          op = ::Windows::ApplicationModel::Contacts::ContactManager::ConvertVCardToContactAsync(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::ApplicationModel::Contacts::Contact^> t)
      {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapContact(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 RequestStoreAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0 || !info[info.Length() -1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: No callback was given")));
        return;
      }

      ::Windows::Foundation::IAsyncOperation<::Windows::ApplicationModel::Contacts::ContactStore^>^ op;


      if (info.Length() == 2
          && info[0]->IsInt32())
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::ContactStoreAccessType arg0 = static_cast<::Windows::ApplicationModel::Contacts::ContactStoreAccessType>(Nan::To<int32_t>(info[0]).FromMaybe(0));
            
          op = ::Windows::ApplicationModel::Contacts::ContactManager::RequestStoreAsync(arg0);
        } catch (Platform::Exception ^exception) {
            NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
            return;
        }
      }
      else if (info.Length() == 1)
      {
        try
        {
          op = ::Windows::ApplicationModel::Contacts::ContactManager::RequestStoreAsync();
        } 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::ApplicationModel::Contacts::ContactStore^> t)
      {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapContactStore(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 RequestAnnotationStoreAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0 || !info[info.Length() -1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: No callback was given")));
        return;
      }

      ::Windows::Foundation::IAsyncOperation<::Windows::ApplicationModel::Contacts::ContactAnnotationStore^>^ op;


      if (info.Length() == 2
          && info[0]->IsInt32())
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::ContactAnnotationStoreAccessType arg0 = static_cast<::Windows::ApplicationModel::Contacts::ContactAnnotationStoreAccessType>(Nan::To<int32_t>(info[0]).FromMaybe(0));
            
          op = ::Windows::ApplicationModel::Contacts::ContactManager::RequestAnnotationStoreAsync(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::ApplicationModel::Contacts::ContactAnnotationStore^> t)
      {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapContactAnnotationStore(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 GetForUser(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::System::User^>(info[0]))
      {
        try
        {
          ::Windows::System::User^ arg0 = dynamic_cast<::Windows::System::User^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::ApplicationModel::Contacts::ContactManagerForUser^ result;
          result = ::Windows::ApplicationModel::Contacts::ContactManager::GetForUser(arg0);
          info.GetReturnValue().Set(WrapContactManagerForUser(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 IsShowContactCardSupported(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          bool result;
          result = ::Windows::ApplicationModel::Contacts::ContactManager::IsShowContactCardSupported();
          info.GetReturnValue().Set(Nan::New<Boolean>(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void ShowContactCard(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 4
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info[0])
        && NodeRT::Utils::IsRect(info[1])
        && info[2]->IsInt32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactCardOptions^>(info[3]))
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::Contact^ arg0 = UnwrapContact(info[0]);
          ::Windows::Foundation::Rect arg1 = NodeRT::Utils::RectFromJs(info[1]);
          ::Windows::UI::Popups::Placement arg2 = static_cast<::Windows::UI::Popups::Placement>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          ::Windows::ApplicationModel::Contacts::ContactCardOptions^ arg3 = UnwrapContactCardOptions(info[3]);
          
          ::Windows::ApplicationModel::Contacts::ContactManager::ShowContactCard(arg0, arg1, arg2, arg3);
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info[0])
        && NodeRT::Utils::IsRect(info[1]))
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::Contact^ arg0 = UnwrapContact(info[0]);
          ::Windows::Foundation::Rect arg1 = NodeRT::Utils::RectFromJs(info[1]);
          
          ::Windows::ApplicationModel::Contacts::ContactManager::ShowContactCard(arg0, arg1);
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info[0])
        && NodeRT::Utils::IsRect(info[1])
        && info[2]->IsInt32())
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::Contact^ arg0 = UnwrapContact(info[0]);
          ::Windows::Foundation::Rect arg1 = NodeRT::Utils::RectFromJs(info[1]);
          ::Windows::UI::Popups::Placement arg2 = static_cast<::Windows::UI::Popups::Placement>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          
          ::Windows::ApplicationModel::Contacts::ContactManager::ShowContactCard(arg0, arg1, arg2);
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void IsShowDelayLoadedContactCardSupported(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          bool result;
          result = ::Windows::ApplicationModel::Contacts::ContactManager::IsShowDelayLoadedContactCardSupported();
          info.GetReturnValue().Set(Nan::New<Boolean>(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void ShowDelayLoadedContactCard(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 4
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info[0])
        && NodeRT::Utils::IsRect(info[1])
        && info[2]->IsInt32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactCardOptions^>(info[3]))
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::Contact^ arg0 = UnwrapContact(info[0]);
          ::Windows::Foundation::Rect arg1 = NodeRT::Utils::RectFromJs(info[1]);
          ::Windows::UI::Popups::Placement arg2 = static_cast<::Windows::UI::Popups::Placement>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          ::Windows::ApplicationModel::Contacts::ContactCardOptions^ arg3 = UnwrapContactCardOptions(info[3]);
          
          ::Windows::ApplicationModel::Contacts::ContactCardDelayedDataLoader^ result;
          result = ::Windows::ApplicationModel::Contacts::ContactManager::ShowDelayLoadedContactCard(arg0, arg1, arg2, arg3);
          info.GetReturnValue().Set(WrapContactCardDelayedDataLoader(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info[0])
        && NodeRT::Utils::IsRect(info[1])
        && info[2]->IsInt32())
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::Contact^ arg0 = UnwrapContact(info[0]);
          ::Windows::Foundation::Rect arg1 = NodeRT::Utils::RectFromJs(info[1]);
          ::Windows::UI::Popups::Placement arg2 = static_cast<::Windows::UI::Popups::Placement>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          
          ::Windows::ApplicationModel::Contacts::ContactCardDelayedDataLoader^ result;
          result = ::Windows::ApplicationModel::Contacts::ContactManager::ShowDelayLoadedContactCard(arg0, arg1, arg2);
          info.GetReturnValue().Set(WrapContactCardDelayedDataLoader(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 ShowFullContactCard(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::FullContactCardOptions^>(info[1]))
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::Contact^ arg0 = UnwrapContact(info[0]);
          ::Windows::ApplicationModel::Contacts::FullContactCardOptions^ arg1 = UnwrapFullContactCardOptions(info[1]);
          
          ::Windows::ApplicationModel::Contacts::ContactManager::ShowFullContactCard(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 SystemSortOrderGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::ApplicationModel::Contacts::ContactNameOrder result = ::Windows::ApplicationModel::Contacts::ContactManager::SystemSortOrder;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void SystemSortOrderSetter(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;
      }

      try {


        ::Windows::ApplicationModel::Contacts::ContactNameOrder winRtValue = static_cast<::Windows::ApplicationModel::Contacts::ContactNameOrder>(Nan::To<int32_t>(value).FromMaybe(0));

        ::Windows::ApplicationModel::Contacts::ContactManager::SystemSortOrder = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      

    static void SystemDisplayNameOrderGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        ::Windows::ApplicationModel::Contacts::ContactNameOrder result = ::Windows::ApplicationModel::Contacts::ContactManager::SystemDisplayNameOrder;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void SystemDisplayNameOrderSetter(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;
      }

      try {


        ::Windows::ApplicationModel::Contacts::ContactNameOrder winRtValue = static_cast<::Windows::ApplicationModel::Contacts::ContactNameOrder>(Nan::To<int32_t>(value).FromMaybe(0));

        ::Windows::ApplicationModel::Contacts::ContactManager::SystemDisplayNameOrder = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      

    private:
      ::Windows::ApplicationModel::Contacts::ContactManager^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactManager(::Windows::ApplicationModel::Contacts::ContactManager^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactManager^ UnwrapContactManager(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactManager::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactManager(::Windows::ApplicationModel::Contacts::ContactManager^ 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>(ContactManager::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactManager^ UnwrapContactManager(Local<Value> value) {
     return ContactManager::Unwrap<ContactManager>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactManager(Local<Object> exports) {
    ContactManager::Init(exports);
  }

  class ContactLaunchActionVerbs : 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>("ContactLaunchActionVerbs").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>("call").ToLocalChecked(), CallGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("map").ToLocalChecked(), MapGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("message").ToLocalChecked(), MessageGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("post").ToLocalChecked(), PostGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("videoCall").ToLocalChecked(), VideoCallGetter);


        Nan::Set(exports, Nan::New<String>("ContactLaunchActionVerbs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ContactLaunchActionVerbs(::Windows::ApplicationModel::Contacts::ContactLaunchActionVerbs^ 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::ApplicationModel::Contacts::ContactLaunchActionVerbs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactLaunchActionVerbs^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Contacts::ContactLaunchActionVerbs^) 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());

      ContactLaunchActionVerbs *wrapperInstance = new ContactLaunchActionVerbs(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::ApplicationModel::Contacts::ContactLaunchActionVerbs^>(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::ApplicationModel::Contacts::ContactLaunchActionVerbs^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Contacts::ContactLaunchActionVerbs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapContactLaunchActionVerbs(winRtInstance));
    }







    static void CallGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        Platform::String^ result = ::Windows::ApplicationModel::Contacts::ContactLaunchActionVerbs::Call;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void MapGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        Platform::String^ result = ::Windows::ApplicationModel::Contacts::ContactLaunchActionVerbs::Map;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void MessageGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        Platform::String^ result = ::Windows::ApplicationModel::Contacts::ContactLaunchActionVerbs::Message;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void PostGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        Platform::String^ result = ::Windows::ApplicationModel::Contacts::ContactLaunchActionVerbs::Post;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void VideoCallGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        Platform::String^ result = ::Windows::ApplicationModel::Contacts::ContactLaunchActionVerbs::VideoCall;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    private:
      ::Windows::ApplicationModel::Contacts::ContactLaunchActionVerbs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactLaunchActionVerbs(::Windows::ApplicationModel::Contacts::ContactLaunchActionVerbs^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactLaunchActionVerbs^ UnwrapContactLaunchActionVerbs(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactLaunchActionVerbs::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactLaunchActionVerbs(::Windows::ApplicationModel::Contacts::ContactLaunchActionVerbs^ 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>(ContactLaunchActionVerbs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactLaunchActionVerbs^ UnwrapContactLaunchActionVerbs(Local<Value> value) {
     return ContactLaunchActionVerbs::Unwrap<ContactLaunchActionVerbs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactLaunchActionVerbs(Local<Object> exports) {
    ContactLaunchActionVerbs::Init(exports);
  }

  class ContactField : 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>("ContactField").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("category").ToLocalChecked(), CategoryGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("name").ToLocalChecked(), NameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("type").ToLocalChecked(), TypeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("value").ToLocalChecked(), ValueGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ContactField").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ContactField(::Windows::ApplicationModel::Contacts::ContactField^ 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::ApplicationModel::Contacts::ContactField^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactField^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Contacts::ContactField^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && info[0]->IsString()
        && info[1]->IsInt32())
      {
        try {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::ApplicationModel::Contacts::ContactFieldType arg1 = static_cast<::Windows::ApplicationModel::Contacts::ContactFieldType>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          winRtInstance = ref new ::Windows::ApplicationModel::Contacts::ContactField(arg0,arg1);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && info[0]->IsString()
        && info[1]->IsInt32()
        && info[2]->IsInt32())
      {
        try {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::ApplicationModel::Contacts::ContactFieldType arg1 = static_cast<::Windows::ApplicationModel::Contacts::ContactFieldType>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          ::Windows::ApplicationModel::Contacts::ContactFieldCategory arg2 = static_cast<::Windows::ApplicationModel::Contacts::ContactFieldCategory>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          
          winRtInstance = ref new ::Windows::ApplicationModel::Contacts::ContactField(arg0,arg1,arg2);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 4
        && info[0]->IsString()
        && info[1]->IsString()
        && info[2]->IsInt32()
        && info[3]->IsInt32())
      {
        try {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          ::Windows::ApplicationModel::Contacts::ContactFieldType arg2 = static_cast<::Windows::ApplicationModel::Contacts::ContactFieldType>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          ::Windows::ApplicationModel::Contacts::ContactFieldCategory arg3 = static_cast<::Windows::ApplicationModel::Contacts::ContactFieldCategory>(Nan::To<int32_t>(info[3]).FromMaybe(0));
          
          winRtInstance = ref new ::Windows::ApplicationModel::Contacts::ContactField(arg0,arg1,arg2,arg3);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      ContactField *wrapperInstance = new ContactField(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::ApplicationModel::Contacts::ContactField^>(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::ApplicationModel::Contacts::ContactField^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Contacts::ContactField^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapContactField(winRtInstance));
    }





    static void CategoryGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactField^>(info.This())) {
        return;
      }

      ContactField *wrapper = ContactField::Unwrap<ContactField>(info.This());

      try  {
        ::Windows::ApplicationModel::Contacts::ContactFieldCategory result = wrapper->_instance->Category;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void NameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactField^>(info.This())) {
        return;
      }

      ContactField *wrapper = ContactField::Unwrap<ContactField>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Name;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TypeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactField^>(info.This())) {
        return;
      }

      ContactField *wrapper = ContactField::Unwrap<ContactField>(info.This());

      try  {
        ::Windows::ApplicationModel::Contacts::ContactFieldType result = wrapper->_instance->Type;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ValueGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactField^>(info.This())) {
        return;
      }

      ContactField *wrapper = ContactField::Unwrap<ContactField>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Value;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::ApplicationModel::Contacts::ContactField^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactField(::Windows::ApplicationModel::Contacts::ContactField^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactField^ UnwrapContactField(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactField::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactField(::Windows::ApplicationModel::Contacts::ContactField^ 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>(ContactField::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactField^ UnwrapContactField(Local<Value> value) {
     return ContactField::Unwrap<ContactField>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactField(Local<Object> exports) {
    ContactField::Init(exports);
  }

  class ContactLocationField : 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>("ContactLocationField").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("category").ToLocalChecked(), CategoryGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("name").ToLocalChecked(), NameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("type").ToLocalChecked(), TypeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("value").ToLocalChecked(), ValueGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("city").ToLocalChecked(), CityGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("country").ToLocalChecked(), CountryGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("postalCode").ToLocalChecked(), PostalCodeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("region").ToLocalChecked(), RegionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("street").ToLocalChecked(), StreetGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("unstructuredAddress").ToLocalChecked(), UnstructuredAddressGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ContactLocationField").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ContactLocationField(::Windows::ApplicationModel::Contacts::ContactLocationField^ 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::ApplicationModel::Contacts::ContactLocationField^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactLocationField^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Contacts::ContactLocationField^) 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::ApplicationModel::Contacts::ContactLocationField(arg0);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && info[0]->IsString()
        && info[1]->IsInt32())
      {
        try {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::ApplicationModel::Contacts::ContactFieldCategory arg1 = static_cast<::Windows::ApplicationModel::Contacts::ContactFieldCategory>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          winRtInstance = ref new ::Windows::ApplicationModel::Contacts::ContactLocationField(arg0,arg1);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 7
        && info[0]->IsString()
        && info[1]->IsInt32()
        && info[2]->IsString()
        && info[3]->IsString()
        && info[4]->IsString()
        && info[5]->IsString()
        && info[6]->IsString())
      {
        try {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::ApplicationModel::Contacts::ContactFieldCategory arg1 = static_cast<::Windows::ApplicationModel::Contacts::ContactFieldCategory>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          Platform::String^ arg2 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[2])));
          Platform::String^ arg3 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[3])));
          Platform::String^ arg4 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[4])));
          Platform::String^ arg5 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[5])));
          Platform::String^ arg6 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[6])));
          
          winRtInstance = ref new ::Windows::ApplicationModel::Contacts::ContactLocationField(arg0,arg1,arg2,arg3,arg4,arg5,arg6);
        } 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());

      ContactLocationField *wrapperInstance = new ContactLocationField(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::ApplicationModel::Contacts::ContactLocationField^>(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::ApplicationModel::Contacts::ContactLocationField^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Contacts::ContactLocationField^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapContactLocationField(winRtInstance));
    }





    static void CategoryGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactLocationField^>(info.This())) {
        return;
      }

      ContactLocationField *wrapper = ContactLocationField::Unwrap<ContactLocationField>(info.This());

      try  {
        ::Windows::ApplicationModel::Contacts::ContactFieldCategory result = wrapper->_instance->Category;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void NameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactLocationField^>(info.This())) {
        return;
      }

      ContactLocationField *wrapper = ContactLocationField::Unwrap<ContactLocationField>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Name;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TypeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactLocationField^>(info.This())) {
        return;
      }

      ContactLocationField *wrapper = ContactLocationField::Unwrap<ContactLocationField>(info.This());

      try  {
        ::Windows::ApplicationModel::Contacts::ContactFieldType result = wrapper->_instance->Type;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ValueGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactLocationField^>(info.This())) {
        return;
      }

      ContactLocationField *wrapper = ContactLocationField::Unwrap<ContactLocationField>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Value;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CityGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactLocationField^>(info.This())) {
        return;
      }

      ContactLocationField *wrapper = ContactLocationField::Unwrap<ContactLocationField>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->City;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CountryGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactLocationField^>(info.This())) {
        return;
      }

      ContactLocationField *wrapper = ContactLocationField::Unwrap<ContactLocationField>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Country;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PostalCodeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactLocationField^>(info.This())) {
        return;
      }

      ContactLocationField *wrapper = ContactLocationField::Unwrap<ContactLocationField>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->PostalCode;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RegionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactLocationField^>(info.This())) {
        return;
      }

      ContactLocationField *wrapper = ContactLocationField::Unwrap<ContactLocationField>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Region;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void StreetGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactLocationField^>(info.This())) {
        return;
      }

      ContactLocationField *wrapper = ContactLocationField::Unwrap<ContactLocationField>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Street;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void UnstructuredAddressGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactLocationField^>(info.This())) {
        return;
      }

      ContactLocationField *wrapper = ContactLocationField::Unwrap<ContactLocationField>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->UnstructuredAddress;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::ApplicationModel::Contacts::ContactLocationField^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactLocationField(::Windows::ApplicationModel::Contacts::ContactLocationField^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactLocationField^ UnwrapContactLocationField(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactLocationField::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactLocationField(::Windows::ApplicationModel::Contacts::ContactLocationField^ 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>(ContactLocationField::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactLocationField^ UnwrapContactLocationField(Local<Value> value) {
     return ContactLocationField::Unwrap<ContactLocationField>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactLocationField(Local<Object> exports) {
    ContactLocationField::Init(exports);
  }

  class ContactInstantMessageField : 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>("ContactInstantMessageField").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("category").ToLocalChecked(), CategoryGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("name").ToLocalChecked(), NameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("type").ToLocalChecked(), TypeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("value").ToLocalChecked(), ValueGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("displayText").ToLocalChecked(), DisplayTextGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("launchUri").ToLocalChecked(), LaunchUriGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("service").ToLocalChecked(), ServiceGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("userName").ToLocalChecked(), UserNameGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ContactInstantMessageField").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ContactInstantMessageField(::Windows::ApplicationModel::Contacts::ContactInstantMessageField^ 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::ApplicationModel::Contacts::ContactInstantMessageField^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactInstantMessageField^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Contacts::ContactInstantMessageField^) 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::ApplicationModel::Contacts::ContactInstantMessageField(arg0);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && info[0]->IsString()
        && info[1]->IsInt32())
      {
        try {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::ApplicationModel::Contacts::ContactFieldCategory arg1 = static_cast<::Windows::ApplicationModel::Contacts::ContactFieldCategory>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          winRtInstance = ref new ::Windows::ApplicationModel::Contacts::ContactInstantMessageField(arg0,arg1);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 5
        && info[0]->IsString()
        && info[1]->IsInt32()
        && info[2]->IsString()
        && info[3]->IsString()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(info[4]))
      {
        try {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::ApplicationModel::Contacts::ContactFieldCategory arg1 = static_cast<::Windows::ApplicationModel::Contacts::ContactFieldCategory>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          Platform::String^ arg2 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[2])));
          Platform::String^ arg3 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[3])));
          ::Windows::Foundation::Uri^ arg4 = dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(info[4]));
          
          winRtInstance = ref new ::Windows::ApplicationModel::Contacts::ContactInstantMessageField(arg0,arg1,arg2,arg3,arg4);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

      NodeRT::Utils::SetHiddenValue(info.This(), Nan::New<String>("__winRtInstance__").ToLocalChecked(), True());

      ContactInstantMessageField *wrapperInstance = new ContactInstantMessageField(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::ApplicationModel::Contacts::ContactInstantMessageField^>(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::ApplicationModel::Contacts::ContactInstantMessageField^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Contacts::ContactInstantMessageField^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapContactInstantMessageField(winRtInstance));
    }





    static void CategoryGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactInstantMessageField^>(info.This())) {
        return;
      }

      ContactInstantMessageField *wrapper = ContactInstantMessageField::Unwrap<ContactInstantMessageField>(info.This());

      try  {
        ::Windows::ApplicationModel::Contacts::ContactFieldCategory result = wrapper->_instance->Category;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void NameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactInstantMessageField^>(info.This())) {
        return;
      }

      ContactInstantMessageField *wrapper = ContactInstantMessageField::Unwrap<ContactInstantMessageField>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Name;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TypeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactInstantMessageField^>(info.This())) {
        return;
      }

      ContactInstantMessageField *wrapper = ContactInstantMessageField::Unwrap<ContactInstantMessageField>(info.This());

      try  {
        ::Windows::ApplicationModel::Contacts::ContactFieldType result = wrapper->_instance->Type;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ValueGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactInstantMessageField^>(info.This())) {
        return;
      }

      ContactInstantMessageField *wrapper = ContactInstantMessageField::Unwrap<ContactInstantMessageField>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Value;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DisplayTextGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactInstantMessageField^>(info.This())) {
        return;
      }

      ContactInstantMessageField *wrapper = ContactInstantMessageField::Unwrap<ContactInstantMessageField>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->DisplayText;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void LaunchUriGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactInstantMessageField^>(info.This())) {
        return;
      }

      ContactInstantMessageField *wrapper = ContactInstantMessageField::Unwrap<ContactInstantMessageField>(info.This());

      try  {
        ::Windows::Foundation::Uri^ result = wrapper->_instance->LaunchUri;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "Uri", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ServiceGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactInstantMessageField^>(info.This())) {
        return;
      }

      ContactInstantMessageField *wrapper = ContactInstantMessageField::Unwrap<ContactInstantMessageField>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Service;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void UserNameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactInstantMessageField^>(info.This())) {
        return;
      }

      ContactInstantMessageField *wrapper = ContactInstantMessageField::Unwrap<ContactInstantMessageField>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->UserName;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::ApplicationModel::Contacts::ContactInstantMessageField^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactInstantMessageField(::Windows::ApplicationModel::Contacts::ContactInstantMessageField^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactInstantMessageField^ UnwrapContactInstantMessageField(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactInstantMessageField::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactInstantMessageField(::Windows::ApplicationModel::Contacts::ContactInstantMessageField^ 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>(ContactInstantMessageField::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactInstantMessageField^ UnwrapContactInstantMessageField(Local<Value> value) {
     return ContactInstantMessageField::Unwrap<ContactInstantMessageField>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactInstantMessageField(Local<Object> exports) {
    ContactInstantMessageField::Init(exports);
  }

  class KnownContactField : 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>("KnownContactField").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);






        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetMethod(constructor, "convertNameToType", ConvertNameToType);
        Nan::SetMethod(constructor, "convertTypeToName", ConvertTypeToName);
        Nan::SetAccessor(constructor, Nan::New<String>("email").ToLocalChecked(), EmailGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("instantMessage").ToLocalChecked(), InstantMessageGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("location").ToLocalChecked(), LocationGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("phoneNumber").ToLocalChecked(), PhoneNumberGetter);


        Nan::Set(exports, Nan::New<String>("KnownContactField").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      KnownContactField(::Windows::ApplicationModel::Contacts::KnownContactField^ 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::ApplicationModel::Contacts::KnownContactField^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::KnownContactField^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Contacts::KnownContactField^) 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());

      KnownContactField *wrapperInstance = new KnownContactField(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::ApplicationModel::Contacts::KnownContactField^>(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::ApplicationModel::Contacts::KnownContactField^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Contacts::KnownContactField^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapKnownContactField(winRtInstance));
    }





    static void ConvertNameToType(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::ApplicationModel::Contacts::ContactFieldType result;
          result = ::Windows::ApplicationModel::Contacts::KnownContactField::ConvertNameToType(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 ConvertTypeToName(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::ApplicationModel::Contacts::ContactFieldType arg0 = static_cast<::Windows::ApplicationModel::Contacts::ContactFieldType>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          Platform::String^ result;
          result = ::Windows::ApplicationModel::Contacts::KnownContactField::ConvertTypeToName(arg0);
          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 EmailGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        Platform::String^ result = ::Windows::ApplicationModel::Contacts::KnownContactField::Email;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void InstantMessageGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        Platform::String^ result = ::Windows::ApplicationModel::Contacts::KnownContactField::InstantMessage;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void LocationGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        Platform::String^ result = ::Windows::ApplicationModel::Contacts::KnownContactField::Location;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void PhoneNumberGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      try
      {
        Platform::String^ result = ::Windows::ApplicationModel::Contacts::KnownContactField::PhoneNumber;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    private:
      ::Windows::ApplicationModel::Contacts::KnownContactField^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapKnownContactField(::Windows::ApplicationModel::Contacts::KnownContactField^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::KnownContactField^ UnwrapKnownContactField(Local<Value> value);
  };

  Persistent<FunctionTemplate> KnownContactField::s_constructorTemplate;

  v8::Local<v8::Value> WrapKnownContactField(::Windows::ApplicationModel::Contacts::KnownContactField^ 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>(KnownContactField::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::KnownContactField^ UnwrapKnownContactField(Local<Value> value) {
     return KnownContactField::Unwrap<KnownContactField>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitKnownContactField(Local<Object> exports) {
    KnownContactField::Init(exports);
  }

  class ContactInformation : 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>("ContactInformation").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);

        Local<Function> func;
        Local<FunctionTemplate> funcTemplate;

          
            Nan::SetPrototypeMethod(localRef, "queryCustomFields", QueryCustomFields);
          

          
            Nan::SetPrototypeMethod(localRef, "getThumbnailAsync", GetThumbnailAsync);
          


          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("customFields").ToLocalChecked(), CustomFieldsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("emails").ToLocalChecked(), EmailsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("instantMessages").ToLocalChecked(), InstantMessagesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("locations").ToLocalChecked(), LocationsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("name").ToLocalChecked(), NameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("phoneNumbers").ToLocalChecked(), PhoneNumbersGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ContactInformation").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ContactInformation(::Windows::ApplicationModel::Contacts::ContactInformation^ 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::ApplicationModel::Contacts::ContactInformation^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactInformation^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Contacts::ContactInformation^) 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());

      ContactInformation *wrapperInstance = new ContactInformation(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::ApplicationModel::Contacts::ContactInformation^>(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::ApplicationModel::Contacts::ContactInformation^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Contacts::ContactInformation^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapContactInformation(winRtInstance));
    }

    static void GetThumbnailAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactInformation^>(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;
      }

      ContactInformation *wrapper = ContactInformation::Unwrap<ContactInformation>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::Storage::Streams::IRandomAccessStreamWithContentType^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->GetThumbnailAsync();
        }
        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::Storage::Streams::IRandomAccessStreamWithContentType^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.Storage.Streams", "IRandomAccessStreamWithContentType", 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 QueryCustomFields(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactInformation^>(info.This())) {
        return;
      }

      ContactInformation *wrapper = ContactInformation::Unwrap<ContactInformation>(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])));
          
          ::Windows::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Contacts::ContactField^>^ result;
          result = wrapper->_instance->QueryCustomFields(arg0);
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::ApplicationModel::Contacts::ContactField^>::CreateVectorViewWrapper(result, 
            [](::Windows::ApplicationModel::Contacts::ContactField^ val) -> Local<Value> {
              return WrapContactField(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactField^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Contacts::ContactField^ {
              return UnwrapContactField(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 CustomFieldsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactInformation^>(info.This())) {
        return;
      }

      ContactInformation *wrapper = ContactInformation::Unwrap<ContactInformation>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Contacts::ContactField^>^ result = wrapper->_instance->CustomFields;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::ApplicationModel::Contacts::ContactField^>::CreateVectorViewWrapper(result, 
            [](::Windows::ApplicationModel::Contacts::ContactField^ val) -> Local<Value> {
              return WrapContactField(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactField^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Contacts::ContactField^ {
              return UnwrapContactField(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void EmailsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactInformation^>(info.This())) {
        return;
      }

      ContactInformation *wrapper = ContactInformation::Unwrap<ContactInformation>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Contacts::ContactField^>^ result = wrapper->_instance->Emails;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::ApplicationModel::Contacts::ContactField^>::CreateVectorViewWrapper(result, 
            [](::Windows::ApplicationModel::Contacts::ContactField^ val) -> Local<Value> {
              return WrapContactField(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactField^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Contacts::ContactField^ {
              return UnwrapContactField(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void InstantMessagesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactInformation^>(info.This())) {
        return;
      }

      ContactInformation *wrapper = ContactInformation::Unwrap<ContactInformation>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Contacts::ContactInstantMessageField^>^ result = wrapper->_instance->InstantMessages;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::ApplicationModel::Contacts::ContactInstantMessageField^>::CreateVectorViewWrapper(result, 
            [](::Windows::ApplicationModel::Contacts::ContactInstantMessageField^ val) -> Local<Value> {
              return WrapContactInstantMessageField(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactInstantMessageField^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Contacts::ContactInstantMessageField^ {
              return UnwrapContactInstantMessageField(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void LocationsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactInformation^>(info.This())) {
        return;
      }

      ContactInformation *wrapper = ContactInformation::Unwrap<ContactInformation>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Contacts::ContactLocationField^>^ result = wrapper->_instance->Locations;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::ApplicationModel::Contacts::ContactLocationField^>::CreateVectorViewWrapper(result, 
            [](::Windows::ApplicationModel::Contacts::ContactLocationField^ val) -> Local<Value> {
              return WrapContactLocationField(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactLocationField^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Contacts::ContactLocationField^ {
              return UnwrapContactLocationField(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void NameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactInformation^>(info.This())) {
        return;
      }

      ContactInformation *wrapper = ContactInformation::Unwrap<ContactInformation>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Name;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PhoneNumbersGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactInformation^>(info.This())) {
        return;
      }

      ContactInformation *wrapper = ContactInformation::Unwrap<ContactInformation>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Contacts::ContactField^>^ result = wrapper->_instance->PhoneNumbers;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::ApplicationModel::Contacts::ContactField^>::CreateVectorViewWrapper(result, 
            [](::Windows::ApplicationModel::Contacts::ContactField^ val) -> Local<Value> {
              return WrapContactField(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactField^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Contacts::ContactField^ {
              return UnwrapContactField(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::ApplicationModel::Contacts::ContactInformation^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactInformation(::Windows::ApplicationModel::Contacts::ContactInformation^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactInformation^ UnwrapContactInformation(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactInformation::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactInformation(::Windows::ApplicationModel::Contacts::ContactInformation^ 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>(ContactInformation::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactInformation^ UnwrapContactInformation(Local<Value> value) {
     return ContactInformation::Unwrap<ContactInformation>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactInformation(Local<Object> exports) {
    ContactInformation::Init(exports);
  }

  class IContactFieldFactory : 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>("IContactFieldFactory").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "createField", CreateField);
          




        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("IContactFieldFactory").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      IContactFieldFactory(::Windows::ApplicationModel::Contacts::IContactFieldFactory^ 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::ApplicationModel::Contacts::IContactFieldFactory^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::IContactFieldFactory^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Contacts::IContactFieldFactory^) 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());

      IContactFieldFactory *wrapperInstance = new IContactFieldFactory(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::ApplicationModel::Contacts::IContactFieldFactory^>(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::ApplicationModel::Contacts::IContactFieldFactory^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Contacts::IContactFieldFactory^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapIContactFieldFactory(winRtInstance));
    }


    static void CreateField(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::IContactFieldFactory^>(info.This())) {
        return;
      }

      IContactFieldFactory *wrapper = IContactFieldFactory::Unwrap<IContactFieldFactory>(info.This());

      if (info.Length() == 2
        && info[0]->IsString()
        && info[1]->IsInt32())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::ApplicationModel::Contacts::ContactFieldType arg1 = static_cast<::Windows::ApplicationModel::Contacts::ContactFieldType>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          ::Windows::ApplicationModel::Contacts::ContactField^ result;
          result = wrapper->_instance->CreateField(arg0, arg1);
          info.GetReturnValue().Set(WrapContactField(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && info[0]->IsString()
        && info[1]->IsInt32()
        && info[2]->IsInt32())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::ApplicationModel::Contacts::ContactFieldType arg1 = static_cast<::Windows::ApplicationModel::Contacts::ContactFieldType>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          ::Windows::ApplicationModel::Contacts::ContactFieldCategory arg2 = static_cast<::Windows::ApplicationModel::Contacts::ContactFieldCategory>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          
          ::Windows::ApplicationModel::Contacts::ContactField^ result;
          result = wrapper->_instance->CreateField(arg0, arg1, arg2);
          info.GetReturnValue().Set(WrapContactField(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 4
        && info[0]->IsString()
        && info[1]->IsString()
        && info[2]->IsInt32()
        && info[3]->IsInt32())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          ::Windows::ApplicationModel::Contacts::ContactFieldType arg2 = static_cast<::Windows::ApplicationModel::Contacts::ContactFieldType>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          ::Windows::ApplicationModel::Contacts::ContactFieldCategory arg3 = static_cast<::Windows::ApplicationModel::Contacts::ContactFieldCategory>(Nan::To<int32_t>(info[3]).FromMaybe(0));
          
          ::Windows::ApplicationModel::Contacts::ContactField^ result;
          result = wrapper->_instance->CreateField(arg0, arg1, arg2, arg3);
          info.GetReturnValue().Set(WrapContactField(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::ApplicationModel::Contacts::IContactFieldFactory^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIContactFieldFactory(::Windows::ApplicationModel::Contacts::IContactFieldFactory^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::IContactFieldFactory^ UnwrapIContactFieldFactory(Local<Value> value);
  };

  Persistent<FunctionTemplate> IContactFieldFactory::s_constructorTemplate;

  v8::Local<v8::Value> WrapIContactFieldFactory(::Windows::ApplicationModel::Contacts::IContactFieldFactory^ 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>(IContactFieldFactory::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::IContactFieldFactory^ UnwrapIContactFieldFactory(Local<Value> value) {
     return IContactFieldFactory::Unwrap<IContactFieldFactory>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIContactFieldFactory(Local<Object> exports) {
    IContactFieldFactory::Init(exports);
  }

  class IContactLocationFieldFactory : 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>("IContactLocationFieldFactory").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "createLocation", CreateLocation);
          




        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("IContactLocationFieldFactory").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      IContactLocationFieldFactory(::Windows::ApplicationModel::Contacts::IContactLocationFieldFactory^ 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::ApplicationModel::Contacts::IContactLocationFieldFactory^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::IContactLocationFieldFactory^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Contacts::IContactLocationFieldFactory^) 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());

      IContactLocationFieldFactory *wrapperInstance = new IContactLocationFieldFactory(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::ApplicationModel::Contacts::IContactLocationFieldFactory^>(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::ApplicationModel::Contacts::IContactLocationFieldFactory^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Contacts::IContactLocationFieldFactory^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapIContactLocationFieldFactory(winRtInstance));
    }


    static void CreateLocation(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::IContactLocationFieldFactory^>(info.This())) {
        return;
      }

      IContactLocationFieldFactory *wrapper = IContactLocationFieldFactory::Unwrap<IContactLocationFieldFactory>(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])));
          
          ::Windows::ApplicationModel::Contacts::ContactLocationField^ result;
          result = wrapper->_instance->CreateLocation(arg0);
          info.GetReturnValue().Set(WrapContactLocationField(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && info[0]->IsString()
        && info[1]->IsInt32())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::ApplicationModel::Contacts::ContactFieldCategory arg1 = static_cast<::Windows::ApplicationModel::Contacts::ContactFieldCategory>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          ::Windows::ApplicationModel::Contacts::ContactLocationField^ result;
          result = wrapper->_instance->CreateLocation(arg0, arg1);
          info.GetReturnValue().Set(WrapContactLocationField(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 7
        && info[0]->IsString()
        && info[1]->IsInt32()
        && info[2]->IsString()
        && info[3]->IsString()
        && info[4]->IsString()
        && info[5]->IsString()
        && info[6]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::ApplicationModel::Contacts::ContactFieldCategory arg1 = static_cast<::Windows::ApplicationModel::Contacts::ContactFieldCategory>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          Platform::String^ arg2 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[2])));
          Platform::String^ arg3 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[3])));
          Platform::String^ arg4 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[4])));
          Platform::String^ arg5 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[5])));
          Platform::String^ arg6 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[6])));
          
          ::Windows::ApplicationModel::Contacts::ContactLocationField^ result;
          result = wrapper->_instance->CreateLocation(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
          info.GetReturnValue().Set(WrapContactLocationField(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::ApplicationModel::Contacts::IContactLocationFieldFactory^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIContactLocationFieldFactory(::Windows::ApplicationModel::Contacts::IContactLocationFieldFactory^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::IContactLocationFieldFactory^ UnwrapIContactLocationFieldFactory(Local<Value> value);
  };

  Persistent<FunctionTemplate> IContactLocationFieldFactory::s_constructorTemplate;

  v8::Local<v8::Value> WrapIContactLocationFieldFactory(::Windows::ApplicationModel::Contacts::IContactLocationFieldFactory^ 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>(IContactLocationFieldFactory::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::IContactLocationFieldFactory^ UnwrapIContactLocationFieldFactory(Local<Value> value) {
     return IContactLocationFieldFactory::Unwrap<IContactLocationFieldFactory>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIContactLocationFieldFactory(Local<Object> exports) {
    IContactLocationFieldFactory::Init(exports);
  }

  class IContactInstantMessageFieldFactory : 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>("IContactInstantMessageFieldFactory").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "createInstantMessage", CreateInstantMessage);
          




        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("IContactInstantMessageFieldFactory").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      IContactInstantMessageFieldFactory(::Windows::ApplicationModel::Contacts::IContactInstantMessageFieldFactory^ 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::ApplicationModel::Contacts::IContactInstantMessageFieldFactory^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::IContactInstantMessageFieldFactory^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Contacts::IContactInstantMessageFieldFactory^) 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());

      IContactInstantMessageFieldFactory *wrapperInstance = new IContactInstantMessageFieldFactory(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::ApplicationModel::Contacts::IContactInstantMessageFieldFactory^>(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::ApplicationModel::Contacts::IContactInstantMessageFieldFactory^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Contacts::IContactInstantMessageFieldFactory^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapIContactInstantMessageFieldFactory(winRtInstance));
    }


    static void CreateInstantMessage(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::IContactInstantMessageFieldFactory^>(info.This())) {
        return;
      }

      IContactInstantMessageFieldFactory *wrapper = IContactInstantMessageFieldFactory::Unwrap<IContactInstantMessageFieldFactory>(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])));
          
          ::Windows::ApplicationModel::Contacts::ContactInstantMessageField^ result;
          result = wrapper->_instance->CreateInstantMessage(arg0);
          info.GetReturnValue().Set(WrapContactInstantMessageField(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && info[0]->IsString()
        && info[1]->IsInt32())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::ApplicationModel::Contacts::ContactFieldCategory arg1 = static_cast<::Windows::ApplicationModel::Contacts::ContactFieldCategory>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          ::Windows::ApplicationModel::Contacts::ContactInstantMessageField^ result;
          result = wrapper->_instance->CreateInstantMessage(arg0, arg1);
          info.GetReturnValue().Set(WrapContactInstantMessageField(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 5
        && info[0]->IsString()
        && info[1]->IsInt32()
        && info[2]->IsString()
        && info[3]->IsString()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(info[4]))
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::ApplicationModel::Contacts::ContactFieldCategory arg1 = static_cast<::Windows::ApplicationModel::Contacts::ContactFieldCategory>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          Platform::String^ arg2 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[2])));
          Platform::String^ arg3 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[3])));
          ::Windows::Foundation::Uri^ arg4 = dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(info[4]));
          
          ::Windows::ApplicationModel::Contacts::ContactInstantMessageField^ result;
          result = wrapper->_instance->CreateInstantMessage(arg0, arg1, arg2, arg3, arg4);
          info.GetReturnValue().Set(WrapContactInstantMessageField(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::ApplicationModel::Contacts::IContactInstantMessageFieldFactory^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIContactInstantMessageFieldFactory(::Windows::ApplicationModel::Contacts::IContactInstantMessageFieldFactory^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::IContactInstantMessageFieldFactory^ UnwrapIContactInstantMessageFieldFactory(Local<Value> value);
  };

  Persistent<FunctionTemplate> IContactInstantMessageFieldFactory::s_constructorTemplate;

  v8::Local<v8::Value> WrapIContactInstantMessageFieldFactory(::Windows::ApplicationModel::Contacts::IContactInstantMessageFieldFactory^ 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>(IContactInstantMessageFieldFactory::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::IContactInstantMessageFieldFactory^ UnwrapIContactInstantMessageFieldFactory(Local<Value> value) {
     return IContactInstantMessageFieldFactory::Unwrap<IContactInstantMessageFieldFactory>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIContactInstantMessageFieldFactory(Local<Object> exports) {
    IContactInstantMessageFieldFactory::Init(exports);
  }

  class ContactFieldFactory : 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>("ContactFieldFactory").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "createField", CreateField);
            Nan::SetPrototypeMethod(localRef, "createLocation", CreateLocation);
            Nan::SetPrototypeMethod(localRef, "createInstantMessage", CreateInstantMessage);
          




        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ContactFieldFactory").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ContactFieldFactory(::Windows::ApplicationModel::Contacts::ContactFieldFactory^ 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::ApplicationModel::Contacts::ContactFieldFactory^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactFieldFactory^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Contacts::ContactFieldFactory^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::ApplicationModel::Contacts::ContactFieldFactory();
        } 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());

      ContactFieldFactory *wrapperInstance = new ContactFieldFactory(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::ApplicationModel::Contacts::ContactFieldFactory^>(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::ApplicationModel::Contacts::ContactFieldFactory^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Contacts::ContactFieldFactory^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapContactFieldFactory(winRtInstance));
    }


    static void CreateField(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactFieldFactory^>(info.This())) {
        return;
      }

      ContactFieldFactory *wrapper = ContactFieldFactory::Unwrap<ContactFieldFactory>(info.This());

      if (info.Length() == 2
        && info[0]->IsString()
        && info[1]->IsInt32())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::ApplicationModel::Contacts::ContactFieldType arg1 = static_cast<::Windows::ApplicationModel::Contacts::ContactFieldType>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          ::Windows::ApplicationModel::Contacts::ContactField^ result;
          result = wrapper->_instance->CreateField(arg0, arg1);
          info.GetReturnValue().Set(WrapContactField(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && info[0]->IsString()
        && info[1]->IsInt32()
        && info[2]->IsInt32())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::ApplicationModel::Contacts::ContactFieldType arg1 = static_cast<::Windows::ApplicationModel::Contacts::ContactFieldType>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          ::Windows::ApplicationModel::Contacts::ContactFieldCategory arg2 = static_cast<::Windows::ApplicationModel::Contacts::ContactFieldCategory>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          
          ::Windows::ApplicationModel::Contacts::ContactField^ result;
          result = wrapper->_instance->CreateField(arg0, arg1, arg2);
          info.GetReturnValue().Set(WrapContactField(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 4
        && info[0]->IsString()
        && info[1]->IsString()
        && info[2]->IsInt32()
        && info[3]->IsInt32())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          ::Windows::ApplicationModel::Contacts::ContactFieldType arg2 = static_cast<::Windows::ApplicationModel::Contacts::ContactFieldType>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          ::Windows::ApplicationModel::Contacts::ContactFieldCategory arg3 = static_cast<::Windows::ApplicationModel::Contacts::ContactFieldCategory>(Nan::To<int32_t>(info[3]).FromMaybe(0));
          
          ::Windows::ApplicationModel::Contacts::ContactField^ result;
          result = wrapper->_instance->CreateField(arg0, arg1, arg2, arg3);
          info.GetReturnValue().Set(WrapContactField(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 CreateLocation(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactFieldFactory^>(info.This())) {
        return;
      }

      ContactFieldFactory *wrapper = ContactFieldFactory::Unwrap<ContactFieldFactory>(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])));
          
          ::Windows::ApplicationModel::Contacts::ContactLocationField^ result;
          result = wrapper->_instance->CreateLocation(arg0);
          info.GetReturnValue().Set(WrapContactLocationField(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && info[0]->IsString()
        && info[1]->IsInt32())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::ApplicationModel::Contacts::ContactFieldCategory arg1 = static_cast<::Windows::ApplicationModel::Contacts::ContactFieldCategory>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          ::Windows::ApplicationModel::Contacts::ContactLocationField^ result;
          result = wrapper->_instance->CreateLocation(arg0, arg1);
          info.GetReturnValue().Set(WrapContactLocationField(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 7
        && info[0]->IsString()
        && info[1]->IsInt32()
        && info[2]->IsString()
        && info[3]->IsString()
        && info[4]->IsString()
        && info[5]->IsString()
        && info[6]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::ApplicationModel::Contacts::ContactFieldCategory arg1 = static_cast<::Windows::ApplicationModel::Contacts::ContactFieldCategory>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          Platform::String^ arg2 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[2])));
          Platform::String^ arg3 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[3])));
          Platform::String^ arg4 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[4])));
          Platform::String^ arg5 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[5])));
          Platform::String^ arg6 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[6])));
          
          ::Windows::ApplicationModel::Contacts::ContactLocationField^ result;
          result = wrapper->_instance->CreateLocation(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
          info.GetReturnValue().Set(WrapContactLocationField(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 CreateInstantMessage(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactFieldFactory^>(info.This())) {
        return;
      }

      ContactFieldFactory *wrapper = ContactFieldFactory::Unwrap<ContactFieldFactory>(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])));
          
          ::Windows::ApplicationModel::Contacts::ContactInstantMessageField^ result;
          result = wrapper->_instance->CreateInstantMessage(arg0);
          info.GetReturnValue().Set(WrapContactInstantMessageField(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && info[0]->IsString()
        && info[1]->IsInt32())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::ApplicationModel::Contacts::ContactFieldCategory arg1 = static_cast<::Windows::ApplicationModel::Contacts::ContactFieldCategory>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          ::Windows::ApplicationModel::Contacts::ContactInstantMessageField^ result;
          result = wrapper->_instance->CreateInstantMessage(arg0, arg1);
          info.GetReturnValue().Set(WrapContactInstantMessageField(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 5
        && info[0]->IsString()
        && info[1]->IsInt32()
        && info[2]->IsString()
        && info[3]->IsString()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(info[4]))
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::ApplicationModel::Contacts::ContactFieldCategory arg1 = static_cast<::Windows::ApplicationModel::Contacts::ContactFieldCategory>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          Platform::String^ arg2 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[2])));
          Platform::String^ arg3 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[3])));
          ::Windows::Foundation::Uri^ arg4 = dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(info[4]));
          
          ::Windows::ApplicationModel::Contacts::ContactInstantMessageField^ result;
          result = wrapper->_instance->CreateInstantMessage(arg0, arg1, arg2, arg3, arg4);
          info.GetReturnValue().Set(WrapContactInstantMessageField(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::ApplicationModel::Contacts::ContactFieldFactory^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactFieldFactory(::Windows::ApplicationModel::Contacts::ContactFieldFactory^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactFieldFactory^ UnwrapContactFieldFactory(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactFieldFactory::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactFieldFactory(::Windows::ApplicationModel::Contacts::ContactFieldFactory^ 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>(ContactFieldFactory::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactFieldFactory^ UnwrapContactFieldFactory(Local<Value> value) {
     return ContactFieldFactory::Unwrap<ContactFieldFactory>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactFieldFactory(Local<Object> exports) {
    ContactFieldFactory::Init(exports);
  }

  class ContactPicker : 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>("ContactPicker").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);

        Local<Function> func;
        Local<FunctionTemplate> funcTemplate;


          
            Nan::SetPrototypeMethod(localRef, "pickSingleContactAsync", PickSingleContactAsync);
            Nan::SetPrototypeMethod(localRef, "pickMultipleContactsAsync", PickMultipleContactsAsync);
            Nan::SetPrototypeMethod(localRef, "pickContactAsync", PickContactAsync);
            Nan::SetPrototypeMethod(localRef, "pickContactsAsync", PickContactsAsync);
          


          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("selectionMode").ToLocalChecked(), SelectionModeGetter, SelectionModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("commitButtonText").ToLocalChecked(), CommitButtonTextGetter, CommitButtonTextSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("desiredFields").ToLocalChecked(), DesiredFieldsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("desiredFieldsWithContactFieldType").ToLocalChecked(), DesiredFieldsWithContactFieldTypeGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ContactPicker").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ContactPicker(::Windows::ApplicationModel::Contacts::ContactPicker^ 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::ApplicationModel::Contacts::ContactPicker^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactPicker^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Contacts::ContactPicker^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 0)
      {
        try {
          winRtInstance = ref new ::Windows::ApplicationModel::Contacts::ContactPicker();
        } 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());

      ContactPicker *wrapperInstance = new ContactPicker(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::ApplicationModel::Contacts::ContactPicker^>(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::ApplicationModel::Contacts::ContactPicker^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Contacts::ContactPicker^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapContactPicker(winRtInstance));
    }

    static void PickSingleContactAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactPicker^>(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;
      }

      ContactPicker *wrapper = ContactPicker::Unwrap<ContactPicker>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::ApplicationModel::Contacts::ContactInformation^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->PickSingleContactAsync();
        }
        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::ApplicationModel::Contacts::ContactInformation^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapContactInformation(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 PickMultipleContactsAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactPicker^>(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;
      }

      ContactPicker *wrapper = ContactPicker::Unwrap<ContactPicker>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Contacts::ContactInformation^>^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->PickMultipleContactsAsync();
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

      auto opTask = create_task(op);
      uv_async_t* asyncToken = NodeUtils::Async::GetAsyncToken(info[info.Length() -1].As<Function>());

      opTask.then( [asyncToken] (task<::Windows::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Contacts::ContactInformation^>^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = NodeRT::Collections::VectorViewWrapper<::Windows::ApplicationModel::Contacts::ContactInformation^>::CreateVectorViewWrapper(result, 
            [](::Windows::ApplicationModel::Contacts::ContactInformation^ val) -> Local<Value> {
              return WrapContactInformation(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactInformation^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Contacts::ContactInformation^ {
              return UnwrapContactInformation(value);
            }
          );
              if (tryCatch.HasCaught())
              {
                error = Nan::To<Object>(tryCatch.Exception()).ToLocalChecked();
              }
              else
              {
                error = Undefined();
              }
              if (arg1.IsEmpty()) arg1 = Undefined();
            }
            Local<Value> args[] = {error, arg1};


            invokeCallback(_countof(args), args);
          });
        } catch (Platform::Exception^ exception) {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {
            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

            Local<Value> args[] = {error};
            invokeCallback(_countof(args), args);
          });
        }
      });
    }
    static void PickContactAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactPicker^>(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;
      }

      ContactPicker *wrapper = ContactPicker::Unwrap<ContactPicker>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::ApplicationModel::Contacts::Contact^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->PickContactAsync();
        }
        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::ApplicationModel::Contacts::Contact^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapContact(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 PickContactsAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactPicker^>(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;
      }

      ContactPicker *wrapper = ContactPicker::Unwrap<ContactPicker>(info.This());

      ::Windows::Foundation::IAsyncOperation<::Windows::Foundation::Collections::IVector<::Windows::ApplicationModel::Contacts::Contact^>^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->PickContactsAsync();
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

      auto opTask = create_task(op);
      uv_async_t* asyncToken = NodeUtils::Async::GetAsyncToken(info[info.Length() -1].As<Function>());

      opTask.then( [asyncToken] (task<::Windows::Foundation::Collections::IVector<::Windows::ApplicationModel::Contacts::Contact^>^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = NodeRT::Collections::VectorWrapper<::Windows::ApplicationModel::Contacts::Contact^>::CreateVectorWrapper(result, 
            [](::Windows::ApplicationModel::Contacts::Contact^ val) -> Local<Value> {
              return WrapContact(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::Contact^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Contacts::Contact^ {
              return UnwrapContact(value);
            }
          );
              if (tryCatch.HasCaught())
              {
                error = Nan::To<Object>(tryCatch.Exception()).ToLocalChecked();
              }
              else
              {
                error = Undefined();
              }
              if (arg1.IsEmpty()) arg1 = Undefined();
            }
            Local<Value> args[] = {error, arg1};


            invokeCallback(_countof(args), args);
          });
        } catch (Platform::Exception^ exception) {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {
            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

            Local<Value> args[] = {error};
            invokeCallback(_countof(args), args);
          });
        }
      });
    }




    static void SelectionModeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactPicker^>(info.This())) {
        return;
      }

      ContactPicker *wrapper = ContactPicker::Unwrap<ContactPicker>(info.This());

      try  {
        ::Windows::ApplicationModel::Contacts::ContactSelectionMode result = wrapper->_instance->SelectionMode;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SelectionModeSetter(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::ApplicationModel::Contacts::ContactPicker^>(info.This())) {
        return;
      }

      ContactPicker *wrapper = ContactPicker::Unwrap<ContactPicker>(info.This());

      try {

        ::Windows::ApplicationModel::Contacts::ContactSelectionMode winRtValue = static_cast<::Windows::ApplicationModel::Contacts::ContactSelectionMode>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->SelectionMode = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void CommitButtonTextGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactPicker^>(info.This())) {
        return;
      }

      ContactPicker *wrapper = ContactPicker::Unwrap<ContactPicker>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->CommitButtonText;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CommitButtonTextSetter(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::ApplicationModel::Contacts::ContactPicker^>(info.This())) {
        return;
      }

      ContactPicker *wrapper = ContactPicker::Unwrap<ContactPicker>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->CommitButtonText = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void DesiredFieldsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactPicker^>(info.This())) {
        return;
      }

      ContactPicker *wrapper = ContactPicker::Unwrap<ContactPicker>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVector<::Platform::String^>^ result = wrapper->_instance->DesiredFields;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Platform::String^>::CreateVectorWrapper(result, 
            [](::Platform::String^ val) -> Local<Value> {
              return NodeRT::Utils::NewString(val->Data());
            },
            [](Local<Value> value) -> bool {
              return value->IsString();
            },
            [](Local<Value> value) -> ::Platform::String^ {
              return ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DesiredFieldsWithContactFieldTypeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Contacts::ContactPicker^>(info.This())) {
        return;
      }

      ContactPicker *wrapper = ContactPicker::Unwrap<ContactPicker>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::ApplicationModel::Contacts::ContactFieldType>^ result = wrapper->_instance->DesiredFieldsWithContactFieldType;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::ApplicationModel::Contacts::ContactFieldType>::CreateVectorWrapper(result, 
            [](::Windows::ApplicationModel::Contacts::ContactFieldType val) -> Local<Value> {
              return Nan::New<Integer>(static_cast<int>(val));
            },
            [](Local<Value> value) -> bool {
              return value->IsInt32();
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Contacts::ContactFieldType {
              return static_cast<::Windows::ApplicationModel::Contacts::ContactFieldType>(Nan::To<int32_t>(value).FromMaybe(0));
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::ApplicationModel::Contacts::ContactPicker^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapContactPicker(::Windows::ApplicationModel::Contacts::ContactPicker^ wintRtInstance);
      friend ::Windows::ApplicationModel::Contacts::ContactPicker^ UnwrapContactPicker(Local<Value> value);
  };

  Persistent<FunctionTemplate> ContactPicker::s_constructorTemplate;

  v8::Local<v8::Value> WrapContactPicker(::Windows::ApplicationModel::Contacts::ContactPicker^ 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>(ContactPicker::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Contacts::ContactPicker^ UnwrapContactPicker(Local<Value> value) {
     return ContactPicker::Unwrap<ContactPicker>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitContactPicker(Local<Object> exports) {
    ContactPicker::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::ApplicationModel::Contacts::InitContactFieldTypeEnum(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactSelectionModeEnum(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactEmailKindEnum(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactPhoneKindEnum(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactAddressKindEnum(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactDateKindEnum(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactChangeTypeEnum(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactRelationshipEnum(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactQueryDesiredFieldsEnum(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactQuerySearchFieldsEnum(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactQuerySearchScopeEnum(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactStoreAccessTypeEnum(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactAnnotationStoreAccessTypeEnum(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactListOtherAppReadAccessEnum(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactListOtherAppWriteAccessEnum(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactMatchReasonKindEnum(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactBatchStatusEnum(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactAnnotationOperationsEnum(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactNameOrderEnum(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactListSyncStatusEnum(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactCardHeaderKindEnum(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactCardTabKindEnum(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactFieldCategoryEnum(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContact(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactCardDelayedDataLoader(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactStore(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactAnnotationStore(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactCardOptions(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitFullContactCardOptions(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactManagerForUser(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactAnnotation(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactAnnotationList(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactChangeTracker(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactChangedEventArgs(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitAggregateContactManager(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactList(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactReader(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactQueryOptions(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactListSyncManager(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactListSyncConstraints(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitIContactField(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactPhone(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactEmail(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactAddress(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactConnectedServiceAccount(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactDate(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactJobInfo(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactSignificantOther(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactWebsite(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactChangedDeferral(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactChange(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactChangeReader(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactBatch(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactMatchReason(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactQueryTextSearch(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactStoreNotificationTriggerDetails(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactManager(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactLaunchActionVerbs(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactField(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactLocationField(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactInstantMessageField(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitKnownContactField(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactInformation(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitIContactFieldFactory(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitIContactLocationFieldFactory(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitIContactInstantMessageFieldFactory(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactFieldFactory(target);
      NodeRT::Windows::ApplicationModel::Contacts::InitContactPicker(target);


  NodeRT::Utils::RegisterNameSpace("Windows.ApplicationModel.Contacts", target);
}



NODE_MODULE(binding, init)