// 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 Chat { 
  v8::Local<v8::Value> WrapChatMessageTransportConfiguration(::Windows::ApplicationModel::Chat::ChatMessageTransportConfiguration^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::ChatMessageTransportConfiguration^ UnwrapChatMessageTransportConfiguration(Local<Value> value);
  
  v8::Local<v8::Value> WrapChatMessage(::Windows::ApplicationModel::Chat::ChatMessage^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::ChatMessage^ UnwrapChatMessage(Local<Value> value);
  
  v8::Local<v8::Value> WrapChatMessageChange(::Windows::ApplicationModel::Chat::ChatMessageChange^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::ChatMessageChange^ UnwrapChatMessageChange(Local<Value> value);
  
  v8::Local<v8::Value> WrapChatMessageChangeReader(::Windows::ApplicationModel::Chat::ChatMessageChangeReader^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::ChatMessageChangeReader^ UnwrapChatMessageChangeReader(Local<Value> value);
  
  v8::Local<v8::Value> WrapChatMessageAttachment(::Windows::ApplicationModel::Chat::ChatMessageAttachment^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::ChatMessageAttachment^ UnwrapChatMessageAttachment(Local<Value> value);
  
  v8::Local<v8::Value> WrapChatConversationThreadingInfo(::Windows::ApplicationModel::Chat::ChatConversationThreadingInfo^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::ChatConversationThreadingInfo^ UnwrapChatConversationThreadingInfo(Local<Value> value);
  
  v8::Local<v8::Value> WrapChatRecipientDeliveryInfo(::Windows::ApplicationModel::Chat::ChatRecipientDeliveryInfo^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::ChatRecipientDeliveryInfo^ UnwrapChatRecipientDeliveryInfo(Local<Value> value);
  
  v8::Local<v8::Value> WrapChatMessageChangeTracker(::Windows::ApplicationModel::Chat::ChatMessageChangeTracker^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::ChatMessageChangeTracker^ UnwrapChatMessageChangeTracker(Local<Value> value);
  
  v8::Local<v8::Value> WrapChatMessageReader(::Windows::ApplicationModel::Chat::ChatMessageReader^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::ChatMessageReader^ UnwrapChatMessageReader(Local<Value> value);
  
  v8::Local<v8::Value> WrapChatMessageValidationResult(::Windows::ApplicationModel::Chat::ChatMessageValidationResult^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::ChatMessageValidationResult^ UnwrapChatMessageValidationResult(Local<Value> value);
  
  v8::Local<v8::Value> WrapChatMessageStore(::Windows::ApplicationModel::Chat::ChatMessageStore^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::ChatMessageStore^ UnwrapChatMessageStore(Local<Value> value);
  
  v8::Local<v8::Value> WrapChatMessageChangedEventArgs(::Windows::ApplicationModel::Chat::ChatMessageChangedEventArgs^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::ChatMessageChangedEventArgs^ UnwrapChatMessageChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapChatConversation(::Windows::ApplicationModel::Chat::ChatConversation^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::ChatConversation^ UnwrapChatConversation(Local<Value> value);
  
  v8::Local<v8::Value> WrapChatConversationReader(::Windows::ApplicationModel::Chat::ChatConversationReader^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::ChatConversationReader^ UnwrapChatConversationReader(Local<Value> value);
  
  v8::Local<v8::Value> WrapChatQueryOptions(::Windows::ApplicationModel::Chat::ChatQueryOptions^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::ChatQueryOptions^ UnwrapChatQueryOptions(Local<Value> value);
  
  v8::Local<v8::Value> WrapChatSearchReader(::Windows::ApplicationModel::Chat::ChatSearchReader^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::ChatSearchReader^ UnwrapChatSearchReader(Local<Value> value);
  
  v8::Local<v8::Value> WrapChatMessageStoreChangedEventArgs(::Windows::ApplicationModel::Chat::ChatMessageStoreChangedEventArgs^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::ChatMessageStoreChangedEventArgs^ UnwrapChatMessageStoreChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapChatMessageChangedDeferral(::Windows::ApplicationModel::Chat::ChatMessageChangedDeferral^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::ChatMessageChangedDeferral^ UnwrapChatMessageChangedDeferral(Local<Value> value);
  
  v8::Local<v8::Value> WrapChatMessageTransport(::Windows::ApplicationModel::Chat::ChatMessageTransport^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::ChatMessageTransport^ UnwrapChatMessageTransport(Local<Value> value);
  
  v8::Local<v8::Value> WrapChatSyncManager(::Windows::ApplicationModel::Chat::ChatSyncManager^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::ChatSyncManager^ UnwrapChatSyncManager(Local<Value> value);
  
  v8::Local<v8::Value> WrapIChatItem(::Windows::ApplicationModel::Chat::IChatItem^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::IChatItem^ UnwrapIChatItem(Local<Value> value);
  
  v8::Local<v8::Value> WrapChatCapabilities(::Windows::ApplicationModel::Chat::ChatCapabilities^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::ChatCapabilities^ UnwrapChatCapabilities(Local<Value> value);
  
  v8::Local<v8::Value> WrapRemoteParticipantComposingChangedEventArgs(::Windows::ApplicationModel::Chat::RemoteParticipantComposingChangedEventArgs^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::RemoteParticipantComposingChangedEventArgs^ UnwrapRemoteParticipantComposingChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapChatSyncConfiguration(::Windows::ApplicationModel::Chat::ChatSyncConfiguration^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::ChatSyncConfiguration^ UnwrapChatSyncConfiguration(Local<Value> value);
  
  v8::Local<v8::Value> WrapRcsEndUserMessageManager(::Windows::ApplicationModel::Chat::RcsEndUserMessageManager^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::RcsEndUserMessageManager^ UnwrapRcsEndUserMessageManager(Local<Value> value);
  
  v8::Local<v8::Value> WrapRcsTransport(::Windows::ApplicationModel::Chat::RcsTransport^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::RcsTransport^ UnwrapRcsTransport(Local<Value> value);
  
  v8::Local<v8::Value> WrapRcsTransportConfiguration(::Windows::ApplicationModel::Chat::RcsTransportConfiguration^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::RcsTransportConfiguration^ UnwrapRcsTransportConfiguration(Local<Value> value);
  
  v8::Local<v8::Value> WrapRcsServiceKindSupportedChangedEventArgs(::Windows::ApplicationModel::Chat::RcsServiceKindSupportedChangedEventArgs^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::RcsServiceKindSupportedChangedEventArgs^ UnwrapRcsServiceKindSupportedChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapRcsEndUserMessageAvailableEventArgs(::Windows::ApplicationModel::Chat::RcsEndUserMessageAvailableEventArgs^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::RcsEndUserMessageAvailableEventArgs^ UnwrapRcsEndUserMessageAvailableEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapRcsEndUserMessageAction(::Windows::ApplicationModel::Chat::RcsEndUserMessageAction^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::RcsEndUserMessageAction^ UnwrapRcsEndUserMessageAction(Local<Value> value);
  
  v8::Local<v8::Value> WrapRcsEndUserMessage(::Windows::ApplicationModel::Chat::RcsEndUserMessage^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::RcsEndUserMessage^ UnwrapRcsEndUserMessage(Local<Value> value);
  
  v8::Local<v8::Value> WrapChatMessageManager(::Windows::ApplicationModel::Chat::ChatMessageManager^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::ChatMessageManager^ UnwrapChatMessageManager(Local<Value> value);
  
  v8::Local<v8::Value> WrapChatMessageNotificationTriggerDetails(::Windows::ApplicationModel::Chat::ChatMessageNotificationTriggerDetails^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::ChatMessageNotificationTriggerDetails^ UnwrapChatMessageNotificationTriggerDetails(Local<Value> value);
  
  v8::Local<v8::Value> WrapChatMessageBlocking(::Windows::ApplicationModel::Chat::ChatMessageBlocking^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::ChatMessageBlocking^ UnwrapChatMessageBlocking(Local<Value> value);
  
  v8::Local<v8::Value> WrapChatCapabilitiesManager(::Windows::ApplicationModel::Chat::ChatCapabilitiesManager^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::ChatCapabilitiesManager^ UnwrapChatCapabilitiesManager(Local<Value> value);
  
  v8::Local<v8::Value> WrapRcsManager(::Windows::ApplicationModel::Chat::RcsManager^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::RcsManager^ UnwrapRcsManager(Local<Value> value);
  
  v8::Local<v8::Value> WrapRcsEndUserMessageAvailableTriggerDetails(::Windows::ApplicationModel::Chat::RcsEndUserMessageAvailableTriggerDetails^ wintRtInstance);
  ::Windows::ApplicationModel::Chat::RcsEndUserMessageAvailableTriggerDetails^ UnwrapRcsEndUserMessageAvailableTriggerDetails(Local<Value> value);
  



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

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

    Nan::Set(exports, Nan::New<String>("ChatMessageStatus").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("draft").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageStatus::Draft)));
    Nan::Set(enumObject, Nan::New<String>("sending").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageStatus::Sending)));
    Nan::Set(enumObject, Nan::New<String>("sent").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageStatus::Sent)));
    Nan::Set(enumObject, Nan::New<String>("sendRetryNeeded").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageStatus::SendRetryNeeded)));
    Nan::Set(enumObject, Nan::New<String>("sendFailed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageStatus::SendFailed)));
    Nan::Set(enumObject, Nan::New<String>("received").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageStatus::Received)));
    Nan::Set(enumObject, Nan::New<String>("receiveDownloadNeeded").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageStatus::ReceiveDownloadNeeded)));
    Nan::Set(enumObject, Nan::New<String>("receiveDownloadFailed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageStatus::ReceiveDownloadFailed)));
    Nan::Set(enumObject, Nan::New<String>("receiveDownloading").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageStatus::ReceiveDownloading)));
    Nan::Set(enumObject, Nan::New<String>("deleted").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageStatus::Deleted)));
    Nan::Set(enumObject, Nan::New<String>("declined").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageStatus::Declined)));
    Nan::Set(enumObject, Nan::New<String>("cancelled").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageStatus::Cancelled)));
    Nan::Set(enumObject, Nan::New<String>("recalled").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageStatus::Recalled)));
    Nan::Set(enumObject, Nan::New<String>("receiveRetryNeeded").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageStatus::ReceiveRetryNeeded)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ChatMessageKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("standard").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageKind::Standard)));
    Nan::Set(enumObject, Nan::New<String>("fileTransferRequest").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageKind::FileTransferRequest)));
    Nan::Set(enumObject, Nan::New<String>("transportCustom").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageKind::TransportCustom)));
    Nan::Set(enumObject, Nan::New<String>("joinedConversation").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageKind::JoinedConversation)));
    Nan::Set(enumObject, Nan::New<String>("leftConversation").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageKind::LeftConversation)));
    Nan::Set(enumObject, Nan::New<String>("otherParticipantJoinedConversation").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageKind::OtherParticipantJoinedConversation)));
    Nan::Set(enumObject, Nan::New<String>("otherParticipantLeftConversation").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageKind::OtherParticipantLeftConversation)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ChatMessageOperatorKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("unspecified").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageOperatorKind::Unspecified)));
    Nan::Set(enumObject, Nan::New<String>("sms").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageOperatorKind::Sms)));
    Nan::Set(enumObject, Nan::New<String>("mms").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageOperatorKind::Mms)));
    Nan::Set(enumObject, Nan::New<String>("rcs").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageOperatorKind::Rcs)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ChatMessageChangeType").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("messageCreated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageChangeType::MessageCreated)));
    Nan::Set(enumObject, Nan::New<String>("messageModified").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageChangeType::MessageModified)));
    Nan::Set(enumObject, Nan::New<String>("messageDeleted").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageChangeType::MessageDeleted)));
    Nan::Set(enumObject, Nan::New<String>("changeTrackingLost").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageChangeType::ChangeTrackingLost)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ChatMessageValidationStatus").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("valid").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageValidationStatus::Valid)));
    Nan::Set(enumObject, Nan::New<String>("noRecipients").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageValidationStatus::NoRecipients)));
    Nan::Set(enumObject, Nan::New<String>("invalidData").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageValidationStatus::InvalidData)));
    Nan::Set(enumObject, Nan::New<String>("messageTooLarge").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageValidationStatus::MessageTooLarge)));
    Nan::Set(enumObject, Nan::New<String>("tooManyRecipients").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageValidationStatus::TooManyRecipients)));
    Nan::Set(enumObject, Nan::New<String>("transportInactive").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageValidationStatus::TransportInactive)));
    Nan::Set(enumObject, Nan::New<String>("transportNotFound").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageValidationStatus::TransportNotFound)));
    Nan::Set(enumObject, Nan::New<String>("tooManyAttachments").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageValidationStatus::TooManyAttachments)));
    Nan::Set(enumObject, Nan::New<String>("invalidRecipients").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageValidationStatus::InvalidRecipients)));
    Nan::Set(enumObject, Nan::New<String>("invalidBody").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageValidationStatus::InvalidBody)));
    Nan::Set(enumObject, Nan::New<String>("invalidOther").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageValidationStatus::InvalidOther)));
    Nan::Set(enumObject, Nan::New<String>("validWithLargeMessage").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageValidationStatus::ValidWithLargeMessage)));
    Nan::Set(enumObject, Nan::New<String>("voiceRoamingRestriction").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageValidationStatus::VoiceRoamingRestriction)));
    Nan::Set(enumObject, Nan::New<String>("dataRoamingRestriction").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageValidationStatus::DataRoamingRestriction)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ChatConversationThreadingKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("participants").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatConversationThreadingKind::Participants)));
    Nan::Set(enumObject, Nan::New<String>("contactId").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatConversationThreadingKind::ContactId)));
    Nan::Set(enumObject, Nan::New<String>("conversationId").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatConversationThreadingKind::ConversationId)));
    Nan::Set(enumObject, Nan::New<String>("custom").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatConversationThreadingKind::Custom)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ChatStoreChangedEventKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("notificationsMissed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatStoreChangedEventKind::NotificationsMissed)));
    Nan::Set(enumObject, Nan::New<String>("storeModified").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatStoreChangedEventKind::StoreModified)));
    Nan::Set(enumObject, Nan::New<String>("messageCreated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatStoreChangedEventKind::MessageCreated)));
    Nan::Set(enumObject, Nan::New<String>("messageModified").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatStoreChangedEventKind::MessageModified)));
    Nan::Set(enumObject, Nan::New<String>("messageDeleted").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatStoreChangedEventKind::MessageDeleted)));
    Nan::Set(enumObject, Nan::New<String>("conversationModified").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatStoreChangedEventKind::ConversationModified)));
    Nan::Set(enumObject, Nan::New<String>("conversationDeleted").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatStoreChangedEventKind::ConversationDeleted)));
    Nan::Set(enumObject, Nan::New<String>("conversationTransportDeleted").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatStoreChangedEventKind::ConversationTransportDeleted)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ChatTransportErrorCodeCategory").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatTransportErrorCodeCategory::None)));
    Nan::Set(enumObject, Nan::New<String>("http").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatTransportErrorCodeCategory::Http)));
    Nan::Set(enumObject, Nan::New<String>("network").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatTransportErrorCodeCategory::Network)));
    Nan::Set(enumObject, Nan::New<String>("mmsServer").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatTransportErrorCodeCategory::MmsServer)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ChatTransportInterpretedErrorCode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatTransportInterpretedErrorCode::None)));
    Nan::Set(enumObject, Nan::New<String>("unknown").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatTransportInterpretedErrorCode::Unknown)));
    Nan::Set(enumObject, Nan::New<String>("invalidRecipientAddress").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatTransportInterpretedErrorCode::InvalidRecipientAddress)));
    Nan::Set(enumObject, Nan::New<String>("networkConnectivity").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatTransportInterpretedErrorCode::NetworkConnectivity)));
    Nan::Set(enumObject, Nan::New<String>("serviceDenied").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatTransportInterpretedErrorCode::ServiceDenied)));
    Nan::Set(enumObject, Nan::New<String>("timeout").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatTransportInterpretedErrorCode::Timeout)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ChatMessageTransportKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("text").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageTransportKind::Text)));
    Nan::Set(enumObject, Nan::New<String>("untriaged").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageTransportKind::Untriaged)));
    Nan::Set(enumObject, Nan::New<String>("blocked").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageTransportKind::Blocked)));
    Nan::Set(enumObject, Nan::New<String>("custom").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatMessageTransportKind::Custom)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("RcsServiceKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("chat").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::RcsServiceKind::Chat)));
    Nan::Set(enumObject, Nan::New<String>("groupChat").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::RcsServiceKind::GroupChat)));
    Nan::Set(enumObject, Nan::New<String>("fileTransfer").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::RcsServiceKind::FileTransfer)));
    Nan::Set(enumObject, Nan::New<String>("capability").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::RcsServiceKind::Capability)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ChatItemKind").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("message").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatItemKind::Message)));
    Nan::Set(enumObject, Nan::New<String>("conversation").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatItemKind::Conversation)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ChatRestoreHistorySpan").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("lastMonth").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatRestoreHistorySpan::LastMonth)));
    Nan::Set(enumObject, Nan::New<String>("lastYear").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatRestoreHistorySpan::LastYear)));
    Nan::Set(enumObject, Nan::New<String>("anyTime").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::ApplicationModel::Chat::ChatRestoreHistorySpan::AnyTime)));
  }



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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("extendedProperties").ToLocalChecked(), ExtendedPropertiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxAttachmentCount").ToLocalChecked(), MaxAttachmentCountGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxMessageSizeInKilobytes").ToLocalChecked(), MaxMessageSizeInKilobytesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxRecipientCount").ToLocalChecked(), MaxRecipientCountGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("supportedVideoFormat").ToLocalChecked(), SupportedVideoFormatGetter);

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



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

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

    private:

      ChatMessageTransportConfiguration(::Windows::ApplicationModel::Chat::ChatMessageTransportConfiguration^ 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::Chat::ChatMessageTransportConfiguration^ winRtInstance;


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

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

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





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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


    private:
      ::Windows::ApplicationModel::Chat::ChatMessageTransportConfiguration^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapChatMessageTransportConfiguration(::Windows::ApplicationModel::Chat::ChatMessageTransportConfiguration^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::ChatMessageTransportConfiguration^ UnwrapChatMessageTransportConfiguration(Local<Value> value);
  };

  Persistent<FunctionTemplate> ChatMessageTransportConfiguration::s_constructorTemplate;

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

  ::Windows::ApplicationModel::Chat::ChatMessageTransportConfiguration^ UnwrapChatMessageTransportConfiguration(Local<Value> value) {
     return ChatMessageTransportConfiguration::Unwrap<ChatMessageTransportConfiguration>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitChatMessageTransportConfiguration(Local<Object> exports) {
    ChatMessageTransportConfiguration::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("itemKind").ToLocalChecked(), ItemKindGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isIncoming").ToLocalChecked(), IsIncomingGetter, IsIncomingSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isForwardingDisabled").ToLocalChecked(), IsForwardingDisabledGetter, IsForwardingDisabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("transportId").ToLocalChecked(), TransportIdGetter, TransportIdSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("status").ToLocalChecked(), StatusGetter, StatusSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("from").ToLocalChecked(), FromGetter, FromSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("body").ToLocalChecked(), BodyGetter, BodySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("subject").ToLocalChecked(), SubjectGetter, SubjectSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isRead").ToLocalChecked(), IsReadGetter, IsReadSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("networkTimestamp").ToLocalChecked(), NetworkTimestampGetter, NetworkTimestampSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("localTimestamp").ToLocalChecked(), LocalTimestampGetter, LocalTimestampSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("recipientSendStatuses").ToLocalChecked(), RecipientSendStatusesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("recipients").ToLocalChecked(), RecipientsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("transportFriendlyName").ToLocalChecked(), TransportFriendlyNameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("attachments").ToLocalChecked(), AttachmentsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("id").ToLocalChecked(), IdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isSeen").ToLocalChecked(), IsSeenGetter, IsSeenSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("messageKind").ToLocalChecked(), MessageKindGetter, MessageKindSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isReceivedDuringQuietHours").ToLocalChecked(), IsReceivedDuringQuietHoursGetter, IsReceivedDuringQuietHoursSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isAutoReply").ToLocalChecked(), IsAutoReplyGetter, IsAutoReplySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("estimatedDownloadSize").ToLocalChecked(), EstimatedDownloadSizeGetter, EstimatedDownloadSizeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("threadingInfo").ToLocalChecked(), ThreadingInfoGetter, ThreadingInfoSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("shouldSuppressNotification").ToLocalChecked(), ShouldSuppressNotificationGetter, ShouldSuppressNotificationSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("remoteId").ToLocalChecked(), RemoteIdGetter, RemoteIdSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("messageOperatorKind").ToLocalChecked(), MessageOperatorKindGetter, MessageOperatorKindSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isReplyDisabled").ToLocalChecked(), IsReplyDisabledGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isSimMessage").ToLocalChecked(), IsSimMessageGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("recipientsDeliveryInfos").ToLocalChecked(), RecipientsDeliveryInfosGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("syncId").ToLocalChecked(), SyncIdGetter, SyncIdSetter);

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



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

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

    private:

      ChatMessage(::Windows::ApplicationModel::Chat::ChatMessage^ 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::Chat::ChatMessage^ winRtInstance;


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

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

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





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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

      try {

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

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

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

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

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

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

      try {

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

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

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

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

      try  {
        ::Windows::ApplicationModel::Chat::ChatMessageStatus 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::Chat::ChatMessage^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

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

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

      try {

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

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

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

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

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

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

      try {

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

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

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

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

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

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

      try {

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

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

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

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

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

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

      try {

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

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

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

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

      try  {
        ::Windows::Foundation::DateTime result = wrapper->_instance->NetworkTimestamp;
        info.GetReturnValue().Set(NodeRT::Utils::DateTimeToJS(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void NetworkTimestampSetter(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::Chat::ChatMessage^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

      try  {
        ::Windows::Foundation::DateTime result = wrapper->_instance->LocalTimestamp;
        info.GetReturnValue().Set(NodeRT::Utils::DateTimeToJS(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void LocalTimestampSetter(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::Chat::ChatMessage^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

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

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

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

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

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

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

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::ApplicationModel::Chat::ChatMessageAttachment^>^ result = wrapper->_instance->Attachments;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::ApplicationModel::Chat::ChatMessageAttachment^>::CreateVectorWrapper(result, 
            [](::Windows::ApplicationModel::Chat::ChatMessageAttachment^ val) -> Local<Value> {
              return WrapChatMessageAttachment(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::ChatMessageAttachment^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Chat::ChatMessageAttachment^ {
              return UnwrapChatMessageAttachment(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::Chat::ChatMessage^>(info.This())) {
        return;
      }

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

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

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

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

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

      try {

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

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

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

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

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

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

      try {

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

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

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

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

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

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

      try {

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

      try  {
        ::Windows::ApplicationModel::Chat::ChatConversationThreadingInfo^ result = wrapper->_instance->ThreadingInfo;
        info.GetReturnValue().Set(WrapChatConversationThreadingInfo(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ThreadingInfoSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

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

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

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

      try {

        ::Windows::ApplicationModel::Chat::ChatConversationThreadingInfo^ winRtValue = dynamic_cast<::Windows::ApplicationModel::Chat::ChatConversationThreadingInfo^>(NodeRT::Utils::GetObjectInstance(value));

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

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

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

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

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

      try {

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

        wrapper->_instance->ShouldSuppressNotification = 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::Chat::ChatMessage^>(info.This())) {
        return;
      }

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try {

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

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


    private:
      ::Windows::ApplicationModel::Chat::ChatMessage^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapChatMessage(::Windows::ApplicationModel::Chat::ChatMessage^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::ChatMessage^ UnwrapChatMessage(Local<Value> value);
  };

  Persistent<FunctionTemplate> ChatMessage::s_constructorTemplate;

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

  ::Windows::ApplicationModel::Chat::ChatMessage^ UnwrapChatMessage(Local<Value> value) {
     return ChatMessage::Unwrap<ChatMessage>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitChatMessage(Local<Object> exports) {
    ChatMessage::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("changeType").ToLocalChecked(), ChangeTypeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("message").ToLocalChecked(), MessageGetter);

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



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

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

    private:

      ChatMessageChange(::Windows::ApplicationModel::Chat::ChatMessageChange^ 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::Chat::ChatMessageChange^ winRtInstance;


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

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

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





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

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

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

      try  {
        ::Windows::ApplicationModel::Chat::ChatMessageChangeType 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 MessageGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

      try  {
        ::Windows::ApplicationModel::Chat::ChatMessage^ result = wrapper->_instance->Message;
        info.GetReturnValue().Set(WrapChatMessage(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::ApplicationModel::Chat::ChatMessageChange^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapChatMessageChange(::Windows::ApplicationModel::Chat::ChatMessageChange^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::ChatMessageChange^ UnwrapChatMessageChange(Local<Value> value);
  };

  Persistent<FunctionTemplate> ChatMessageChange::s_constructorTemplate;

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

  ::Windows::ApplicationModel::Chat::ChatMessageChange^ UnwrapChatMessageChange(Local<Value> value) {
     return ChatMessageChange::Unwrap<ChatMessageChange>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitChatMessageChange(Local<Object> exports) {
    ChatMessageChange::Init(exports);
  }

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

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

    private:

      ChatMessageChangeReader(::Windows::ApplicationModel::Chat::ChatMessageChangeReader^ 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::Chat::ChatMessageChangeReader^ winRtInstance;


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

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

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

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

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Chat::ChatMessageChange^>^>^ 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::Chat::ChatMessageChange^>^> 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::Chat::ChatMessageChange^>::CreateVectorViewWrapper(result, 
            [](::Windows::ApplicationModel::Chat::ChatMessageChange^ val) -> Local<Value> {
              return WrapChatMessageChange(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::ChatMessageChange^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Chat::ChatMessageChange^ {
              return UnwrapChatMessageChange(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::Chat::ChatMessageChangeReader^>(info.This())) {
        return;
      }

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::ChatMessageChange^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Chat::ChatMessageChange^ arg0 = UnwrapChatMessageChange(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::Chat::ChatMessageChangeReader^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapChatMessageChangeReader(::Windows::ApplicationModel::Chat::ChatMessageChangeReader^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::ChatMessageChangeReader^ UnwrapChatMessageChangeReader(Local<Value> value);
  };

  Persistent<FunctionTemplate> ChatMessageChangeReader::s_constructorTemplate;

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

  ::Windows::ApplicationModel::Chat::ChatMessageChangeReader^ UnwrapChatMessageChangeReader(Local<Value> value) {
     return ChatMessageChangeReader::Unwrap<ChatMessageChangeReader>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitChatMessageChangeReader(Local<Object> exports) {
    ChatMessageChangeReader::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("text").ToLocalChecked(), TextGetter, TextSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("mimeType").ToLocalChecked(), MimeTypeGetter, MimeTypeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("groupId").ToLocalChecked(), GroupIdGetter, GroupIdSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dataStreamReference").ToLocalChecked(), DataStreamReferenceGetter, DataStreamReferenceSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("transferProgress").ToLocalChecked(), TransferProgressGetter, TransferProgressSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("thumbnail").ToLocalChecked(), ThumbnailGetter, ThumbnailSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("originalFileName").ToLocalChecked(), OriginalFileNameGetter, OriginalFileNameSetter);

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



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

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

    private:

      ChatMessageAttachment(::Windows::ApplicationModel::Chat::ChatMessageAttachment^ 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::Chat::ChatMessageAttachment^ winRtInstance;


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

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

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

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





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

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

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

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

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

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

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

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

      try {

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

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

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

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

      try  {
        unsigned int result = wrapper->_instance->GroupId;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void GroupIdSetter(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::Chat::ChatMessageAttachment^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

      try  {
        ::Windows::Storage::Streams::IRandomAccessStreamReference^ result = wrapper->_instance->DataStreamReference;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Storage.Streams", "IRandomAccessStreamReference", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DataStreamReferenceSetter(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::Chat::ChatMessageAttachment^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

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

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

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

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

      try {

        double winRtValue = Nan::To<double>(value).FromMaybe(0.0);

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

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

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

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

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

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

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

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

      try {

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

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


    private:
      ::Windows::ApplicationModel::Chat::ChatMessageAttachment^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapChatMessageAttachment(::Windows::ApplicationModel::Chat::ChatMessageAttachment^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::ChatMessageAttachment^ UnwrapChatMessageAttachment(Local<Value> value);
  };

  Persistent<FunctionTemplate> ChatMessageAttachment::s_constructorTemplate;

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

  ::Windows::ApplicationModel::Chat::ChatMessageAttachment^ UnwrapChatMessageAttachment(Local<Value> value) {
     return ChatMessageAttachment::Unwrap<ChatMessageAttachment>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitChatMessageAttachment(Local<Object> exports) {
    ChatMessageAttachment::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("kind").ToLocalChecked(), KindGetter, KindSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("custom").ToLocalChecked(), CustomGetter, CustomSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("conversationId").ToLocalChecked(), ConversationIdGetter, ConversationIdSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("contactId").ToLocalChecked(), ContactIdGetter, ContactIdSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("participants").ToLocalChecked(), ParticipantsGetter);

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



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

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

    private:

      ChatConversationThreadingInfo(::Windows::ApplicationModel::Chat::ChatConversationThreadingInfo^ 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::Chat::ChatConversationThreadingInfo^ winRtInstance;


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

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

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





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

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

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

      try  {
        ::Windows::ApplicationModel::Chat::ChatConversationThreadingKind 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::Chat::ChatConversationThreadingInfo^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

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

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

      try {

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

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

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

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

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

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

      try {

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

        wrapper->_instance->ConversationId = 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::Chat::ChatConversationThreadingInfo^>(info.This())) {
        return;
      }

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

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Platform::String^>^ result = wrapper->_instance->Participants;
        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::Chat::ChatConversationThreadingInfo^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapChatConversationThreadingInfo(::Windows::ApplicationModel::Chat::ChatConversationThreadingInfo^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::ChatConversationThreadingInfo^ UnwrapChatConversationThreadingInfo(Local<Value> value);
  };

  Persistent<FunctionTemplate> ChatConversationThreadingInfo::s_constructorTemplate;

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

  ::Windows::ApplicationModel::Chat::ChatConversationThreadingInfo^ UnwrapChatConversationThreadingInfo(Local<Value> value) {
     return ChatConversationThreadingInfo::Unwrap<ChatConversationThreadingInfo>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitChatConversationThreadingInfo(Local<Object> exports) {
    ChatConversationThreadingInfo::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("transportAddress").ToLocalChecked(), TransportAddressGetter, TransportAddressSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("readTime").ToLocalChecked(), ReadTimeGetter, ReadTimeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("deliveryTime").ToLocalChecked(), DeliveryTimeGetter, DeliveryTimeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isErrorPermanent").ToLocalChecked(), IsErrorPermanentGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("status").ToLocalChecked(), StatusGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("transportErrorCode").ToLocalChecked(), TransportErrorCodeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("transportErrorCodeCategory").ToLocalChecked(), TransportErrorCodeCategoryGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("transportInterpretedErrorCode").ToLocalChecked(), TransportInterpretedErrorCodeGetter);

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



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

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

    private:

      ChatRecipientDeliveryInfo(::Windows::ApplicationModel::Chat::ChatRecipientDeliveryInfo^ 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::Chat::ChatRecipientDeliveryInfo^ winRtInstance;


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

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

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





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

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

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

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

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

      try {

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

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

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

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

      try  {
        ::Platform::IBox<::Windows::Foundation::DateTime>^ result = wrapper->_instance->ReadTime;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::DateTimeToJS(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ReadTimeSetter(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::Chat::ChatRecipientDeliveryInfo^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

      try  {
        ::Platform::IBox<::Windows::Foundation::DateTime>^ result = wrapper->_instance->DeliveryTime;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::DateTimeToJS(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DeliveryTimeSetter(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::Chat::ChatRecipientDeliveryInfo^>(info.This())) {
        return;
      }

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

      try {

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

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

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

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

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

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

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

      try  {
        ::Windows::ApplicationModel::Chat::ChatMessageStatus 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 TransportErrorCodeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

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

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

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

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


    private:
      ::Windows::ApplicationModel::Chat::ChatRecipientDeliveryInfo^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapChatRecipientDeliveryInfo(::Windows::ApplicationModel::Chat::ChatRecipientDeliveryInfo^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::ChatRecipientDeliveryInfo^ UnwrapChatRecipientDeliveryInfo(Local<Value> value);
  };

  Persistent<FunctionTemplate> ChatRecipientDeliveryInfo::s_constructorTemplate;

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

  ::Windows::ApplicationModel::Chat::ChatRecipientDeliveryInfo^ UnwrapChatRecipientDeliveryInfo(Local<Value> value) {
     return ChatRecipientDeliveryInfo::Unwrap<ChatRecipientDeliveryInfo>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitChatRecipientDeliveryInfo(Local<Object> exports) {
    ChatRecipientDeliveryInfo::Init(exports);
  }

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

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

    private:

      ChatMessageChangeTracker(::Windows::ApplicationModel::Chat::ChatMessageChangeTracker^ 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::Chat::ChatMessageChangeTracker^ winRtInstance;


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

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

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


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

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

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::ApplicationModel::Chat::ChatMessageChangeReader^ result;
          result = wrapper->_instance->GetChangeReader();
          info.GetReturnValue().Set(WrapChatMessageChangeReader(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::Chat::ChatMessageChangeTracker^>(info.This())) {
        return;
      }

      ChatMessageChangeTracker *wrapper = ChatMessageChangeTracker::Unwrap<ChatMessageChangeTracker>(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::Chat::ChatMessageChangeTracker^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapChatMessageChangeTracker(::Windows::ApplicationModel::Chat::ChatMessageChangeTracker^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::ChatMessageChangeTracker^ UnwrapChatMessageChangeTracker(Local<Value> value);
  };

  Persistent<FunctionTemplate> ChatMessageChangeTracker::s_constructorTemplate;

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

  ::Windows::ApplicationModel::Chat::ChatMessageChangeTracker^ UnwrapChatMessageChangeTracker(Local<Value> value) {
     return ChatMessageChangeTracker::Unwrap<ChatMessageChangeTracker>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitChatMessageChangeTracker(Local<Object> exports) {
    ChatMessageChangeTracker::Init(exports);
  }

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

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


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

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

    private:

      ChatMessageReader(::Windows::ApplicationModel::Chat::ChatMessageReader^ 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::Chat::ChatMessageReader^ winRtInstance;


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

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

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

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

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Chat::ChatMessage^>^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->ReadBatchAsync();
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && info[0]->IsInt32())
      {
        try
        {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          op = wrapper->_instance->ReadBatchAsync(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::Chat::ChatMessage^>^> 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::Chat::ChatMessage^>::CreateVectorViewWrapper(result, 
            [](::Windows::ApplicationModel::Chat::ChatMessage^ val) -> Local<Value> {
              return WrapChatMessage(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::ChatMessage^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Chat::ChatMessage^ {
              return UnwrapChatMessage(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::Chat::ChatMessageReader^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapChatMessageReader(::Windows::ApplicationModel::Chat::ChatMessageReader^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::ChatMessageReader^ UnwrapChatMessageReader(Local<Value> value);
  };

  Persistent<FunctionTemplate> ChatMessageReader::s_constructorTemplate;

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

  ::Windows::ApplicationModel::Chat::ChatMessageReader^ UnwrapChatMessageReader(Local<Value> value) {
     return ChatMessageReader::Unwrap<ChatMessageReader>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitChatMessageReader(Local<Object> exports) {
    ChatMessageReader::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxPartCount").ToLocalChecked(), MaxPartCountGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("partCount").ToLocalChecked(), PartCountGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("remainingCharacterCountInPart").ToLocalChecked(), RemainingCharacterCountInPartGetter);
            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>("ChatMessageValidationResult").ToLocalChecked(), constructor);
      }

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

    private:

      ChatMessageValidationResult(::Windows::ApplicationModel::Chat::ChatMessageValidationResult^ 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::Chat::ChatMessageValidationResult^ winRtInstance;


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

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

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





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

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

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

      try  {
        ::Platform::IBox<unsigned int>^ result = wrapper->_instance->MaxPartCount;
        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 PartCountGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

      try  {
        ::Platform::IBox<unsigned int>^ result = wrapper->_instance->PartCount;
        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 RemainingCharacterCountInPartGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

      try  {
        ::Platform::IBox<unsigned int>^ result = wrapper->_instance->RemainingCharacterCountInPart;
        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 StatusGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

      try  {
        ::Windows::ApplicationModel::Chat::ChatMessageValidationStatus 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::Chat::ChatMessageValidationResult^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapChatMessageValidationResult(::Windows::ApplicationModel::Chat::ChatMessageValidationResult^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::ChatMessageValidationResult^ UnwrapChatMessageValidationResult(Local<Value> value);
  };

  Persistent<FunctionTemplate> ChatMessageValidationResult::s_constructorTemplate;

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

  ::Windows::ApplicationModel::Chat::ChatMessageValidationResult^ UnwrapChatMessageValidationResult(Local<Value> value) {
     return ChatMessageValidationResult::Unwrap<ChatMessageValidationResult>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitChatMessageValidationResult(Local<Object> exports) {
    ChatMessageValidationResult::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "getMessageReader", GetMessageReader);
            Nan::SetPrototypeMethod(localRef, "validateMessage", ValidateMessage);
            Nan::SetPrototypeMethod(localRef, "getConversationReader", GetConversationReader);
            Nan::SetPrototypeMethod(localRef, "getSearchReader", GetSearchReader);
          

          
            Nan::SetPrototypeMethod(localRef, "deleteMessageAsync", DeleteMessageAsync);
            Nan::SetPrototypeMethod(localRef, "downloadMessageAsync", DownloadMessageAsync);
            Nan::SetPrototypeMethod(localRef, "getMessageAsync", GetMessageAsync);
            Nan::SetPrototypeMethod(localRef, "markMessageReadAsync", MarkMessageReadAsync);
            Nan::SetPrototypeMethod(localRef, "retrySendMessageAsync", RetrySendMessageAsync);
            Nan::SetPrototypeMethod(localRef, "sendMessageAsync", SendMessageAsync);
            Nan::SetPrototypeMethod(localRef, "forwardMessageAsync", ForwardMessageAsync);
            Nan::SetPrototypeMethod(localRef, "getConversationAsync", GetConversationAsync);
            Nan::SetPrototypeMethod(localRef, "getConversationFromThreadingInfoAsync", GetConversationFromThreadingInfoAsync);
            Nan::SetPrototypeMethod(localRef, "getMessageByRemoteIdAsync", GetMessageByRemoteIdAsync);
            Nan::SetPrototypeMethod(localRef, "getUnseenCountAsync", GetUnseenCountAsync);
            Nan::SetPrototypeMethod(localRef, "markAsSeenAsync", MarkAsSeenAsync);
            Nan::SetPrototypeMethod(localRef, "saveMessageAsync", SaveMessageAsync);
            Nan::SetPrototypeMethod(localRef, "tryCancelDownloadMessageAsync", TryCancelDownloadMessageAsync);
            Nan::SetPrototypeMethod(localRef, "tryCancelSendMessageAsync", TryCancelSendMessageAsync);
            Nan::SetPrototypeMethod(localRef, "getMessageBySyncIdAsync", GetMessageBySyncIdAsync);
          

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

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

    private:

      ChatMessageStore(::Windows::ApplicationModel::Chat::ChatMessageStore^ 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::Chat::ChatMessageStore^ winRtInstance;


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

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

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

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

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

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

      ::Windows::Foundation::IAsyncAction^ 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->DeleteMessageAsync(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 DownloadMessageAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      ::Windows::Foundation::IAsyncAction^ 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->DownloadMessageAsync(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 GetMessageAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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


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

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

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

      ::Windows::Foundation::IAsyncAction^ 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->MarkMessageReadAsync(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 RetrySendMessageAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      ::Windows::Foundation::IAsyncAction^ 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->RetrySendMessageAsync(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 SendMessageAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::ChatMessage^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Chat::ChatMessage^ arg0 = UnwrapChatMessage(info[0]);
          
          op = wrapper->_instance->SendMessageAsync(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 ForwardMessageAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::ApplicationModel::Chat::ChatMessage^>^ op;


      if (info.Length() == 3
        && info[0]->IsString()
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Platform::String^>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Foundation::Collections::IIterable<::Platform::String^>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Platform::String^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Platform::String^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return (!NodeRT::Utils::IsWinRtWrapper(value));
                 },
                 [](Local<Value> value) -> ::Platform::String^ {
                   return ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Platform::String^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          op = wrapper->_instance->ForwardMessageAsync(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::Chat::ChatMessage^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::ApplicationModel::Chat::ChatConversation^>^ 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->GetConversationAsync(arg0);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && info[0]->IsString()
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Platform::String^>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Foundation::Collections::IIterable<::Platform::String^>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Platform::String^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Platform::String^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return (!NodeRT::Utils::IsWinRtWrapper(value));
                 },
                 [](Local<Value> value) -> ::Platform::String^ {
                   return ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Platform::String^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          op = wrapper->_instance->GetConversationAsync(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::Chat::ChatConversation^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::ApplicationModel::Chat::ChatConversation^>^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::ChatConversationThreadingInfo^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Chat::ChatConversationThreadingInfo^ arg0 = UnwrapChatConversationThreadingInfo(info[0]);
          
          op = wrapper->_instance->GetConversationFromThreadingInfoAsync(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::Chat::ChatConversation^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::ApplicationModel::Chat::ChatMessage^>^ op;


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


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

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

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

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


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->GetUnseenCountAsync();
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Platform::String^>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<::Platform::String^>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Platform::String^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Platform::String^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return (!NodeRT::Utils::IsWinRtWrapper(value));
                 },
                 [](Local<Value> value) -> ::Platform::String^ {
                   return ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Platform::String^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          op = wrapper->_instance->GetUnseenCountAsync(arg0);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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


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

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

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

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

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


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->MarkAsSeenAsync();
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Platform::String^>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<::Platform::String^>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Platform::String^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Platform::String^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return (!NodeRT::Utils::IsWinRtWrapper(value));
                 },
                 [](Local<Value> value) -> ::Platform::String^ {
                   return ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Platform::String^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          op = wrapper->_instance->MarkAsSeenAsync(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 SaveMessageAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::ChatMessage^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Chat::ChatMessage^ arg0 = UnwrapChatMessage(info[0]);
          
          op = wrapper->_instance->SaveMessageAsync(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 TryCancelDownloadMessageAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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


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

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

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

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


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

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

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

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


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

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::ApplicationModel::Chat::ChatMessageReader^ result;
          result = wrapper->_instance->GetMessageReader();
          info.GetReturnValue().Set(WrapChatMessageReader(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && info[0]->IsNumber())
      {
        try
        {
          ::Windows::Foundation::TimeSpan arg0 = NodeRT::Utils::TimeSpanFromMilli(Nan::To<int64_t>(info[0]).FromMaybe(0));
          
          ::Windows::ApplicationModel::Chat::ChatMessageReader^ result;
          result = wrapper->_instance->GetMessageReader(arg0);
          info.GetReturnValue().Set(WrapChatMessageReader(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 ValidateMessage(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::ChatMessage^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Chat::ChatMessage^ arg0 = UnwrapChatMessage(info[0]);
          
          ::Windows::ApplicationModel::Chat::ChatMessageValidationResult^ result;
          result = wrapper->_instance->ValidateMessage(arg0);
          info.GetReturnValue().Set(WrapChatMessageValidationResult(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 GetConversationReader(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::ApplicationModel::Chat::ChatConversationReader^ result;
          result = wrapper->_instance->GetConversationReader();
          info.GetReturnValue().Set(WrapChatConversationReader(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Platform::String^>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<::Platform::String^>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Platform::String^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Platform::String^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return (!NodeRT::Utils::IsWinRtWrapper(value));
                 },
                 [](Local<Value> value) -> ::Platform::String^ {
                   return ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Platform::String^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          ::Windows::ApplicationModel::Chat::ChatConversationReader^ result;
          result = wrapper->_instance->GetConversationReader(arg0);
          info.GetReturnValue().Set(WrapChatConversationReader(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 GetSearchReader(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::ChatQueryOptions^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Chat::ChatQueryOptions^ arg0 = UnwrapChatQueryOptions(info[0]);
          
          ::Windows::ApplicationModel::Chat::ChatSearchReader^ result;
          result = wrapper->_instance->GetSearchReader(arg0);
          info.GetReturnValue().Set(WrapChatSearchReader(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 ChangeTrackerGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

      try  {
        ::Windows::ApplicationModel::Chat::ChatMessageChangeTracker^ result = wrapper->_instance->ChangeTracker;
        info.GetReturnValue().Set(WrapChatMessageChangeTracker(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"messageChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::ChatMessageStore^>(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;
        }
        ChatMessageStore *wrapper = ChatMessageStore::Unwrap<ChatMessageStore>(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->MessageChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::ApplicationModel::Chat::ChatMessageStore^, ::Windows::ApplicationModel::Chat::ChatMessageChangedEventArgs^>(
            [callbackObjPtr](::Windows::ApplicationModel::Chat::ChatMessageStore^ arg0, ::Windows::ApplicationModel::Chat::ChatMessageChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapChatMessageStore(arg0);
                  wrappedArg1 = WrapChatMessageChangedEventArgs(arg1);


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

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

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"storeChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::ChatMessageStore^>(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;
        }
        ChatMessageStore *wrapper = ChatMessageStore::Unwrap<ChatMessageStore>(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->StoreChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::ApplicationModel::Chat::ChatMessageStore^, ::Windows::ApplicationModel::Chat::ChatMessageStoreChangedEventArgs^>(
            [callbackObjPtr](::Windows::ApplicationModel::Chat::ChatMessageStore^ arg0, ::Windows::ApplicationModel::Chat::ChatMessageStoreChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapChatMessageStore(arg0);
                  wrappedArg1 = WrapChatMessageStoreChangedEventArgs(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"messageChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"storeChanged", 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"messageChanged", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::ChatMessageStore^>(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;
          }
          ChatMessageStore *wrapper = ChatMessageStore::Unwrap<ChatMessageStore>(info.This());
          wrapper->_instance->MessageChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"storeChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::ChatMessageStore^>(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;
          }
          ChatMessageStore *wrapper = ChatMessageStore::Unwrap<ChatMessageStore>(info.This());
          wrapper->_instance->StoreChanged::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::Chat::ChatMessageStore^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapChatMessageStore(::Windows::ApplicationModel::Chat::ChatMessageStore^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::ChatMessageStore^ UnwrapChatMessageStore(Local<Value> value);
  };

  Persistent<FunctionTemplate> ChatMessageStore::s_constructorTemplate;

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

  ::Windows::ApplicationModel::Chat::ChatMessageStore^ UnwrapChatMessageStore(Local<Value> value) {
     return ChatMessageStore::Unwrap<ChatMessageStore>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitChatMessageStore(Local<Object> exports) {
    ChatMessageStore::Init(exports);
  }

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

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

    private:

      ChatMessageChangedEventArgs(::Windows::ApplicationModel::Chat::ChatMessageChangedEventArgs^ 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::Chat::ChatMessageChangedEventArgs^ winRtInstance;


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

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

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


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

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

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

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

      friend v8::Local<v8::Value> WrapChatMessageChangedEventArgs(::Windows::ApplicationModel::Chat::ChatMessageChangedEventArgs^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::ChatMessageChangedEventArgs^ UnwrapChatMessageChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> ChatMessageChangedEventArgs::s_constructorTemplate;

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

  ::Windows::ApplicationModel::Chat::ChatMessageChangedEventArgs^ UnwrapChatMessageChangedEventArgs(Local<Value> value) {
     return ChatMessageChangedEventArgs::Unwrap<ChatMessageChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitChatMessageChangedEventArgs(Local<Object> exports) {
    ChatMessageChangedEventArgs::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "getMessageReader", GetMessageReader);
            Nan::SetPrototypeMethod(localRef, "notifyLocalParticipantComposing", NotifyLocalParticipantComposing);
            Nan::SetPrototypeMethod(localRef, "notifyRemoteParticipantComposing", NotifyRemoteParticipantComposing);
          

          
            Nan::SetPrototypeMethod(localRef, "deleteAsync", DeleteAsync);
            Nan::SetPrototypeMethod(localRef, "markMessagesAsReadAsync", MarkMessagesAsReadAsync);
            Nan::SetPrototypeMethod(localRef, "saveAsync", SaveAsync);
          

          
          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>("subject").ToLocalChecked(), SubjectGetter, SubjectSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isConversationMuted").ToLocalChecked(), IsConversationMutedGetter, IsConversationMutedSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("hasUnreadMessages").ToLocalChecked(), HasUnreadMessagesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("id").ToLocalChecked(), IdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("mostRecentMessageId").ToLocalChecked(), MostRecentMessageIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("participants").ToLocalChecked(), ParticipantsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("threadingInfo").ToLocalChecked(), ThreadingInfoGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("canModifyParticipants").ToLocalChecked(), CanModifyParticipantsGetter, CanModifyParticipantsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("itemKind").ToLocalChecked(), ItemKindGetter);

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



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

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

    private:

      ChatConversation(::Windows::ApplicationModel::Chat::ChatConversation^ 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::Chat::ChatConversation^ winRtInstance;


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

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

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

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

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

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

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

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

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


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->MarkMessagesAsReadAsync();
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && info[0]->IsDate())
      {
        try
        {
          ::Windows::Foundation::DateTime arg0 = NodeRT::Utils::DateTimeFromJSDate(info[0]);
          
          op = wrapper->_instance->MarkMessagesAsReadAsync(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 SaveAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::ApplicationModel::Chat::ChatMessageReader^ result;
          result = wrapper->_instance->GetMessageReader();
          info.GetReturnValue().Set(WrapChatMessageReader(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 NotifyLocalParticipantComposing(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 3
        && info[0]->IsString()
        && info[1]->IsString()
        && info[2]->IsBoolean())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          bool arg2 = Nan::To<bool>(info[2]).FromMaybe(false);
          
          wrapper->_instance->NotifyLocalParticipantComposing(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 NotifyRemoteParticipantComposing(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 3
        && info[0]->IsString()
        && info[1]->IsString()
        && info[2]->IsBoolean())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          bool arg2 = Nan::To<bool>(info[2]).FromMaybe(false);
          
          wrapper->_instance->NotifyRemoteParticipantComposing(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 SubjectGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

      try {

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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


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

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

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

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

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"remoteParticipantComposingChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::ChatConversation^>(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;
        }
        ChatConversation *wrapper = ChatConversation::Unwrap<ChatConversation>(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->RemoteParticipantComposingChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::ApplicationModel::Chat::ChatConversation^, ::Windows::ApplicationModel::Chat::RemoteParticipantComposingChangedEventArgs^>(
            [callbackObjPtr](::Windows::ApplicationModel::Chat::ChatConversation^ arg0, ::Windows::ApplicationModel::Chat::RemoteParticipantComposingChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapChatConversation(arg0);
                  wrappedArg1 = WrapRemoteParticipantComposingChangedEventArgs(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"remoteParticipantComposingChanged", 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"remoteParticipantComposingChanged", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::ChatConversation^>(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;
          }
          ChatConversation *wrapper = ChatConversation::Unwrap<ChatConversation>(info.This());
          wrapper->_instance->RemoteParticipantComposingChanged::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::Chat::ChatConversation^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapChatConversation(::Windows::ApplicationModel::Chat::ChatConversation^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::ChatConversation^ UnwrapChatConversation(Local<Value> value);
  };

  Persistent<FunctionTemplate> ChatConversation::s_constructorTemplate;

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

  ::Windows::ApplicationModel::Chat::ChatConversation^ UnwrapChatConversation(Local<Value> value) {
     return ChatConversation::Unwrap<ChatConversation>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitChatConversation(Local<Object> exports) {
    ChatConversation::Init(exports);
  }

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

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


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

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

    private:

      ChatConversationReader(::Windows::ApplicationModel::Chat::ChatConversationReader^ 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::Chat::ChatConversationReader^ winRtInstance;


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

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

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

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

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Chat::ChatConversation^>^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->ReadBatchAsync();
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && info[0]->IsInt32())
      {
        try
        {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          op = wrapper->_instance->ReadBatchAsync(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::Chat::ChatConversation^>^> 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::Chat::ChatConversation^>::CreateVectorViewWrapper(result, 
            [](::Windows::ApplicationModel::Chat::ChatConversation^ val) -> Local<Value> {
              return WrapChatConversation(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::ChatConversation^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Chat::ChatConversation^ {
              return UnwrapChatConversation(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::Chat::ChatConversationReader^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapChatConversationReader(::Windows::ApplicationModel::Chat::ChatConversationReader^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::ChatConversationReader^ UnwrapChatConversationReader(Local<Value> value);
  };

  Persistent<FunctionTemplate> ChatConversationReader::s_constructorTemplate;

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

  ::Windows::ApplicationModel::Chat::ChatConversationReader^ UnwrapChatConversationReader(Local<Value> value) {
     return ChatConversationReader::Unwrap<ChatConversationReader>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitChatConversationReader(Local<Object> exports) {
    ChatConversationReader::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("searchString").ToLocalChecked(), SearchStringGetter, SearchStringSetter);

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



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

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

    private:

      ChatQueryOptions(::Windows::ApplicationModel::Chat::ChatQueryOptions^ 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::Chat::ChatQueryOptions^ winRtInstance;


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

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

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





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

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

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

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

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

      try {

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

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


    private:
      ::Windows::ApplicationModel::Chat::ChatQueryOptions^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapChatQueryOptions(::Windows::ApplicationModel::Chat::ChatQueryOptions^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::ChatQueryOptions^ UnwrapChatQueryOptions(Local<Value> value);
  };

  Persistent<FunctionTemplate> ChatQueryOptions::s_constructorTemplate;

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

  ::Windows::ApplicationModel::Chat::ChatQueryOptions^ UnwrapChatQueryOptions(Local<Value> value) {
     return ChatQueryOptions::Unwrap<ChatQueryOptions>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitChatQueryOptions(Local<Object> exports) {
    ChatQueryOptions::Init(exports);
  }

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

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


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

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

    private:

      ChatSearchReader(::Windows::ApplicationModel::Chat::ChatSearchReader^ 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::Chat::ChatSearchReader^ winRtInstance;


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

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

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

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

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Chat::IChatItem^>^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->ReadBatchAsync();
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && info[0]->IsInt32())
      {
        try
        {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          op = wrapper->_instance->ReadBatchAsync(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::Chat::IChatItem^>^> 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::Chat::IChatItem^>::CreateVectorViewWrapper(result, 
            [](::Windows::ApplicationModel::Chat::IChatItem^ val) -> Local<Value> {
              return WrapIChatItem(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::IChatItem^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Chat::IChatItem^ {
              return UnwrapIChatItem(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::Chat::ChatSearchReader^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapChatSearchReader(::Windows::ApplicationModel::Chat::ChatSearchReader^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::ChatSearchReader^ UnwrapChatSearchReader(Local<Value> value);
  };

  Persistent<FunctionTemplate> ChatSearchReader::s_constructorTemplate;

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

  ::Windows::ApplicationModel::Chat::ChatSearchReader^ UnwrapChatSearchReader(Local<Value> value) {
     return ChatSearchReader::Unwrap<ChatSearchReader>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitChatSearchReader(Local<Object> exports) {
    ChatSearchReader::Init(exports);
  }

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





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

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



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

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

    private:

      ChatMessageStoreChangedEventArgs(::Windows::ApplicationModel::Chat::ChatMessageStoreChangedEventArgs^ 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::Chat::ChatMessageStoreChangedEventArgs^ winRtInstance;


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

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

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





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

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

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

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

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

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


    private:
      ::Windows::ApplicationModel::Chat::ChatMessageStoreChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapChatMessageStoreChangedEventArgs(::Windows::ApplicationModel::Chat::ChatMessageStoreChangedEventArgs^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::ChatMessageStoreChangedEventArgs^ UnwrapChatMessageStoreChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> ChatMessageStoreChangedEventArgs::s_constructorTemplate;

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

  ::Windows::ApplicationModel::Chat::ChatMessageStoreChangedEventArgs^ UnwrapChatMessageStoreChangedEventArgs(Local<Value> value) {
     return ChatMessageStoreChangedEventArgs::Unwrap<ChatMessageStoreChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitChatMessageStoreChangedEventArgs(Local<Object> exports) {
    ChatMessageStoreChangedEventArgs::Init(exports);
  }

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

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

    private:

      ChatMessageChangedDeferral(::Windows::ApplicationModel::Chat::ChatMessageChangedDeferral^ 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::Chat::ChatMessageChangedDeferral^ winRtInstance;


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

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

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


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

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

      ChatMessageChangedDeferral *wrapper = ChatMessageChangedDeferral::Unwrap<ChatMessageChangedDeferral>(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::Chat::ChatMessageChangedDeferral^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapChatMessageChangedDeferral(::Windows::ApplicationModel::Chat::ChatMessageChangedDeferral^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::ChatMessageChangedDeferral^ UnwrapChatMessageChangedDeferral(Local<Value> value);
  };

  Persistent<FunctionTemplate> ChatMessageChangedDeferral::s_constructorTemplate;

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

  ::Windows::ApplicationModel::Chat::ChatMessageChangedDeferral^ UnwrapChatMessageChangedDeferral(Local<Value> value) {
     return ChatMessageChangedDeferral::Unwrap<ChatMessageChangedDeferral>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitChatMessageChangedDeferral(Local<Object> exports) {
    ChatMessageChangedDeferral::Init(exports);
  }

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

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


          
            Nan::SetPrototypeMethod(localRef, "requestSetAsNotificationProviderAsync", RequestSetAsNotificationProviderAsync);
          


          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isActive").ToLocalChecked(), IsActiveGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isAppSetAsNotificationProvider").ToLocalChecked(), IsAppSetAsNotificationProviderGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("transportFriendlyName").ToLocalChecked(), TransportFriendlyNameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("transportId").ToLocalChecked(), TransportIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("configuration").ToLocalChecked(), ConfigurationGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("transportKind").ToLocalChecked(), TransportKindGetter);

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



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

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

    private:

      ChatMessageTransport(::Windows::ApplicationModel::Chat::ChatMessageTransport^ 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::Chat::ChatMessageTransport^ winRtInstance;


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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


    private:
      ::Windows::ApplicationModel::Chat::ChatMessageTransport^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapChatMessageTransport(::Windows::ApplicationModel::Chat::ChatMessageTransport^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::ChatMessageTransport^ UnwrapChatMessageTransport(Local<Value> value);
  };

  Persistent<FunctionTemplate> ChatMessageTransport::s_constructorTemplate;

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

  ::Windows::ApplicationModel::Chat::ChatMessageTransport^ UnwrapChatMessageTransport(Local<Value> value) {
     return ChatMessageTransport::Unwrap<ChatMessageTransport>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitChatMessageTransport(Local<Object> exports) {
    ChatMessageTransport::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "isAccountAssociated", IsAccountAssociated);
            Nan::SetPrototypeMethod(localRef, "startSync", StartSync);
          

          
            Nan::SetPrototypeMethod(localRef, "associateAccountAsync", AssociateAccountAsync);
            Nan::SetPrototypeMethod(localRef, "unassociateAccountAsync", UnassociateAccountAsync);
            Nan::SetPrototypeMethod(localRef, "setConfigurationAsync", SetConfigurationAsync);
          


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

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



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

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

    private:

      ChatSyncManager(::Windows::ApplicationModel::Chat::ChatSyncManager^ 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::Chat::ChatSyncManager^ winRtInstance;


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

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

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

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

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

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

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


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Security::Credentials::WebAccount^>(info[0]))
      {
        try
        {
          ::Windows::Security::Credentials::WebAccount^ arg0 = dynamic_cast<::Windows::Security::Credentials::WebAccount^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          op = wrapper->_instance->AssociateAccountAsync(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 UnassociateAccountAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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


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

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

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


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


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

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

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

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

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


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

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

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


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


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

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

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

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

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Security::Credentials::WebAccount^>(info[0]))
      {
        try
        {
          ::Windows::Security::Credentials::WebAccount^ arg0 = dynamic_cast<::Windows::Security::Credentials::WebAccount^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          bool result;
          result = wrapper->_instance->IsAccountAssociated(arg0);
          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 StartSync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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

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

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

      try  {
        ::Windows::ApplicationModel::Chat::ChatSyncConfiguration^ result = wrapper->_instance->Configuration;
        info.GetReturnValue().Set(WrapChatSyncConfiguration(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::ApplicationModel::Chat::ChatSyncManager^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapChatSyncManager(::Windows::ApplicationModel::Chat::ChatSyncManager^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::ChatSyncManager^ UnwrapChatSyncManager(Local<Value> value);
  };

  Persistent<FunctionTemplate> ChatSyncManager::s_constructorTemplate;

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

  ::Windows::ApplicationModel::Chat::ChatSyncManager^ UnwrapChatSyncManager(Local<Value> value) {
     return ChatSyncManager::Unwrap<ChatSyncManager>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitChatSyncManager(Local<Object> exports) {
    ChatSyncManager::Init(exports);
  }

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





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

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



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

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

    private:

      IChatItem(::Windows::ApplicationModel::Chat::IChatItem^ 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::Chat::IChatItem^ winRtInstance;


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

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

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





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

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

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

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


    private:
      ::Windows::ApplicationModel::Chat::IChatItem^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIChatItem(::Windows::ApplicationModel::Chat::IChatItem^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::IChatItem^ UnwrapIChatItem(Local<Value> value);
  };

  Persistent<FunctionTemplate> IChatItem::s_constructorTemplate;

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

  ::Windows::ApplicationModel::Chat::IChatItem^ UnwrapIChatItem(Local<Value> value) {
     return IChatItem::Unwrap<IChatItem>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIChatItem(Local<Object> exports) {
    IChatItem::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isChatCapable").ToLocalChecked(), IsChatCapableGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isFileTransferCapable").ToLocalChecked(), IsFileTransferCapableGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isGeoLocationPushCapable").ToLocalChecked(), IsGeoLocationPushCapableGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isIntegratedMessagingCapable").ToLocalChecked(), IsIntegratedMessagingCapableGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isOnline").ToLocalChecked(), IsOnlineGetter);

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



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

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

    private:

      ChatCapabilities(::Windows::ApplicationModel::Chat::ChatCapabilities^ 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::Chat::ChatCapabilities^ winRtInstance;


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

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

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





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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


    private:
      ::Windows::ApplicationModel::Chat::ChatCapabilities^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapChatCapabilities(::Windows::ApplicationModel::Chat::ChatCapabilities^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::ChatCapabilities^ UnwrapChatCapabilities(Local<Value> value);
  };

  Persistent<FunctionTemplate> ChatCapabilities::s_constructorTemplate;

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

  ::Windows::ApplicationModel::Chat::ChatCapabilities^ UnwrapChatCapabilities(Local<Value> value) {
     return ChatCapabilities::Unwrap<ChatCapabilities>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitChatCapabilities(Local<Object> exports) {
    ChatCapabilities::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isComposing").ToLocalChecked(), IsComposingGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("participantAddress").ToLocalChecked(), ParticipantAddressGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("transportId").ToLocalChecked(), TransportIdGetter);

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



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

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

    private:

      RemoteParticipantComposingChangedEventArgs(::Windows::ApplicationModel::Chat::RemoteParticipantComposingChangedEventArgs^ 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::Chat::RemoteParticipantComposingChangedEventArgs^ winRtInstance;


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

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

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





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

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

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

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

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

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

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

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

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

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


    private:
      ::Windows::ApplicationModel::Chat::RemoteParticipantComposingChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapRemoteParticipantComposingChangedEventArgs(::Windows::ApplicationModel::Chat::RemoteParticipantComposingChangedEventArgs^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::RemoteParticipantComposingChangedEventArgs^ UnwrapRemoteParticipantComposingChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> RemoteParticipantComposingChangedEventArgs::s_constructorTemplate;

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

  ::Windows::ApplicationModel::Chat::RemoteParticipantComposingChangedEventArgs^ UnwrapRemoteParticipantComposingChangedEventArgs(Local<Value> value) {
     return RemoteParticipantComposingChangedEventArgs::Unwrap<RemoteParticipantComposingChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitRemoteParticipantComposingChangedEventArgs(Local<Object> exports) {
    RemoteParticipantComposingChangedEventArgs::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("restoreHistorySpan").ToLocalChecked(), RestoreHistorySpanGetter, RestoreHistorySpanSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isSyncEnabled").ToLocalChecked(), IsSyncEnabledGetter, IsSyncEnabledSetter);

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



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

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

    private:

      ChatSyncConfiguration(::Windows::ApplicationModel::Chat::ChatSyncConfiguration^ 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::Chat::ChatSyncConfiguration^ winRtInstance;


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

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

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





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

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

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

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

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

      try {

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

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

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

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

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

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

      try {

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

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


    private:
      ::Windows::ApplicationModel::Chat::ChatSyncConfiguration^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapChatSyncConfiguration(::Windows::ApplicationModel::Chat::ChatSyncConfiguration^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::ChatSyncConfiguration^ UnwrapChatSyncConfiguration(Local<Value> value);
  };

  Persistent<FunctionTemplate> ChatSyncConfiguration::s_constructorTemplate;

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

  ::Windows::ApplicationModel::Chat::ChatSyncConfiguration^ UnwrapChatSyncConfiguration(Local<Value> value) {
     return ChatSyncConfiguration::Unwrap<ChatSyncConfiguration>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitChatSyncConfiguration(Local<Object> exports) {
    ChatSyncConfiguration::Init(exports);
  }

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




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


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



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

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

    private:

      RcsEndUserMessageManager(::Windows::ApplicationModel::Chat::RcsEndUserMessageManager^ 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::Chat::RcsEndUserMessageManager^ winRtInstance;


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

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

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







    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"messageAvailableChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::RcsEndUserMessageManager^>(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;
        }
        RcsEndUserMessageManager *wrapper = RcsEndUserMessageManager::Unwrap<RcsEndUserMessageManager>(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->MessageAvailableChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::ApplicationModel::Chat::RcsEndUserMessageManager^, ::Windows::ApplicationModel::Chat::RcsEndUserMessageAvailableEventArgs^>(
            [callbackObjPtr](::Windows::ApplicationModel::Chat::RcsEndUserMessageManager^ arg0, ::Windows::ApplicationModel::Chat::RcsEndUserMessageAvailableEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapRcsEndUserMessageManager(arg0);
                  wrappedArg1 = WrapRcsEndUserMessageAvailableEventArgs(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"messageAvailableChanged", 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"messageAvailableChanged", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::RcsEndUserMessageManager^>(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;
          }
          RcsEndUserMessageManager *wrapper = RcsEndUserMessageManager::Unwrap<RcsEndUserMessageManager>(info.This());
          wrapper->_instance->MessageAvailableChanged::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::Chat::RcsEndUserMessageManager^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapRcsEndUserMessageManager(::Windows::ApplicationModel::Chat::RcsEndUserMessageManager^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::RcsEndUserMessageManager^ UnwrapRcsEndUserMessageManager(Local<Value> value);
  };

  Persistent<FunctionTemplate> RcsEndUserMessageManager::s_constructorTemplate;

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

  ::Windows::ApplicationModel::Chat::RcsEndUserMessageManager^ UnwrapRcsEndUserMessageManager(Local<Value> value) {
     return RcsEndUserMessageManager::Unwrap<RcsEndUserMessageManager>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitRcsEndUserMessageManager(Local<Object> exports) {
    RcsEndUserMessageManager::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "isStoreAndForwardEnabled", IsStoreAndForwardEnabled);
            Nan::SetPrototypeMethod(localRef, "isServiceKindSupported", IsServiceKindSupported);
          


          
          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>("configuration").ToLocalChecked(), ConfigurationGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("extendedProperties").ToLocalChecked(), ExtendedPropertiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isActive").ToLocalChecked(), IsActiveGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("transportFriendlyName").ToLocalChecked(), TransportFriendlyNameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("transportId").ToLocalChecked(), TransportIdGetter);

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



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

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

    private:

      RcsTransport(::Windows::ApplicationModel::Chat::RcsTransport^ 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::Chat::RcsTransport^ winRtInstance;


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

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

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


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

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

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

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::ApplicationModel::Chat::RcsServiceKind arg0 = static_cast<::Windows::ApplicationModel::Chat::RcsServiceKind>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          bool result;
          result = wrapper->_instance->IsStoreAndForwardEnabled(arg0);
          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 IsServiceKindSupported(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::ApplicationModel::Chat::RcsServiceKind arg0 = static_cast<::Windows::ApplicationModel::Chat::RcsServiceKind>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          bool result;
          result = wrapper->_instance->IsServiceKindSupported(arg0);
          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 ConfigurationGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"serviceKindSupportedChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::RcsTransport^>(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;
        }
        RcsTransport *wrapper = RcsTransport::Unwrap<RcsTransport>(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->ServiceKindSupportedChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::ApplicationModel::Chat::RcsTransport^, ::Windows::ApplicationModel::Chat::RcsServiceKindSupportedChangedEventArgs^>(
            [callbackObjPtr](::Windows::ApplicationModel::Chat::RcsTransport^ arg0, ::Windows::ApplicationModel::Chat::RcsServiceKindSupportedChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapRcsTransport(arg0);
                  wrappedArg1 = WrapRcsServiceKindSupportedChangedEventArgs(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"serviceKindSupportedChanged", 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"serviceKindSupportedChanged", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::RcsTransport^>(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;
          }
          RcsTransport *wrapper = RcsTransport::Unwrap<RcsTransport>(info.This());
          wrapper->_instance->ServiceKindSupportedChanged::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::Chat::RcsTransport^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapRcsTransport(::Windows::ApplicationModel::Chat::RcsTransport^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::RcsTransport^ UnwrapRcsTransport(Local<Value> value);
  };

  Persistent<FunctionTemplate> RcsTransport::s_constructorTemplate;

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

  ::Windows::ApplicationModel::Chat::RcsTransport^ UnwrapRcsTransport(Local<Value> value) {
     return RcsTransport::Unwrap<RcsTransport>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitRcsTransport(Local<Object> exports) {
    RcsTransport::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxAttachmentCount").ToLocalChecked(), MaxAttachmentCountGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxFileSizeInKilobytes").ToLocalChecked(), MaxFileSizeInKilobytesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxGroupMessageSizeInKilobytes").ToLocalChecked(), MaxGroupMessageSizeInKilobytesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxMessageSizeInKilobytes").ToLocalChecked(), MaxMessageSizeInKilobytesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxRecipientCount").ToLocalChecked(), MaxRecipientCountGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("warningFileSizeInKilobytes").ToLocalChecked(), WarningFileSizeInKilobytesGetter);

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



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

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

    private:

      RcsTransportConfiguration(::Windows::ApplicationModel::Chat::RcsTransportConfiguration^ 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::Chat::RcsTransportConfiguration^ winRtInstance;


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

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

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





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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


    private:
      ::Windows::ApplicationModel::Chat::RcsTransportConfiguration^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapRcsTransportConfiguration(::Windows::ApplicationModel::Chat::RcsTransportConfiguration^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::RcsTransportConfiguration^ UnwrapRcsTransportConfiguration(Local<Value> value);
  };

  Persistent<FunctionTemplate> RcsTransportConfiguration::s_constructorTemplate;

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

  ::Windows::ApplicationModel::Chat::RcsTransportConfiguration^ UnwrapRcsTransportConfiguration(Local<Value> value) {
     return RcsTransportConfiguration::Unwrap<RcsTransportConfiguration>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitRcsTransportConfiguration(Local<Object> exports) {
    RcsTransportConfiguration::Init(exports);
  }

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





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

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("RcsServiceKindSupportedChangedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      RcsServiceKindSupportedChangedEventArgs(::Windows::ApplicationModel::Chat::RcsServiceKindSupportedChangedEventArgs^ 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::Chat::RcsServiceKindSupportedChangedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::RcsServiceKindSupportedChangedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Chat::RcsServiceKindSupportedChangedEventArgs^) 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());

      RcsServiceKindSupportedChangedEventArgs *wrapperInstance = new RcsServiceKindSupportedChangedEventArgs(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::Chat::RcsServiceKindSupportedChangedEventArgs^>(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::Chat::RcsServiceKindSupportedChangedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Chat::RcsServiceKindSupportedChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapRcsServiceKindSupportedChangedEventArgs(winRtInstance));
    }





    static void ServiceKindGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::RcsServiceKindSupportedChangedEventArgs^>(info.This())) {
        return;
      }

      RcsServiceKindSupportedChangedEventArgs *wrapper = RcsServiceKindSupportedChangedEventArgs::Unwrap<RcsServiceKindSupportedChangedEventArgs>(info.This());

      try  {
        ::Windows::ApplicationModel::Chat::RcsServiceKind result = wrapper->_instance->ServiceKind;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::ApplicationModel::Chat::RcsServiceKindSupportedChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapRcsServiceKindSupportedChangedEventArgs(::Windows::ApplicationModel::Chat::RcsServiceKindSupportedChangedEventArgs^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::RcsServiceKindSupportedChangedEventArgs^ UnwrapRcsServiceKindSupportedChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> RcsServiceKindSupportedChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapRcsServiceKindSupportedChangedEventArgs(::Windows::ApplicationModel::Chat::RcsServiceKindSupportedChangedEventArgs^ 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>(RcsServiceKindSupportedChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Chat::RcsServiceKindSupportedChangedEventArgs^ UnwrapRcsServiceKindSupportedChangedEventArgs(Local<Value> value) {
     return RcsServiceKindSupportedChangedEventArgs::Unwrap<RcsServiceKindSupportedChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitRcsServiceKindSupportedChangedEventArgs(Local<Object> exports) {
    RcsServiceKindSupportedChangedEventArgs::Init(exports);
  }

  class RcsEndUserMessageAvailableEventArgs : 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>("RcsEndUserMessageAvailableEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isMessageAvailable").ToLocalChecked(), IsMessageAvailableGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("message").ToLocalChecked(), MessageGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("RcsEndUserMessageAvailableEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      RcsEndUserMessageAvailableEventArgs(::Windows::ApplicationModel::Chat::RcsEndUserMessageAvailableEventArgs^ 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::Chat::RcsEndUserMessageAvailableEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::RcsEndUserMessageAvailableEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Chat::RcsEndUserMessageAvailableEventArgs^) 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());

      RcsEndUserMessageAvailableEventArgs *wrapperInstance = new RcsEndUserMessageAvailableEventArgs(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::Chat::RcsEndUserMessageAvailableEventArgs^>(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::Chat::RcsEndUserMessageAvailableEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Chat::RcsEndUserMessageAvailableEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapRcsEndUserMessageAvailableEventArgs(winRtInstance));
    }





    static void IsMessageAvailableGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::RcsEndUserMessageAvailableEventArgs^>(info.This())) {
        return;
      }

      RcsEndUserMessageAvailableEventArgs *wrapper = RcsEndUserMessageAvailableEventArgs::Unwrap<RcsEndUserMessageAvailableEventArgs>(info.This());

      try  {
        bool result = wrapper->_instance->IsMessageAvailable;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MessageGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::RcsEndUserMessageAvailableEventArgs^>(info.This())) {
        return;
      }

      RcsEndUserMessageAvailableEventArgs *wrapper = RcsEndUserMessageAvailableEventArgs::Unwrap<RcsEndUserMessageAvailableEventArgs>(info.This());

      try  {
        ::Windows::ApplicationModel::Chat::RcsEndUserMessage^ result = wrapper->_instance->Message;
        info.GetReturnValue().Set(WrapRcsEndUserMessage(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::ApplicationModel::Chat::RcsEndUserMessageAvailableEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapRcsEndUserMessageAvailableEventArgs(::Windows::ApplicationModel::Chat::RcsEndUserMessageAvailableEventArgs^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::RcsEndUserMessageAvailableEventArgs^ UnwrapRcsEndUserMessageAvailableEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> RcsEndUserMessageAvailableEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapRcsEndUserMessageAvailableEventArgs(::Windows::ApplicationModel::Chat::RcsEndUserMessageAvailableEventArgs^ 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>(RcsEndUserMessageAvailableEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Chat::RcsEndUserMessageAvailableEventArgs^ UnwrapRcsEndUserMessageAvailableEventArgs(Local<Value> value) {
     return RcsEndUserMessageAvailableEventArgs::Unwrap<RcsEndUserMessageAvailableEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitRcsEndUserMessageAvailableEventArgs(Local<Object> exports) {
    RcsEndUserMessageAvailableEventArgs::Init(exports);
  }

  class RcsEndUserMessageAction : 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>("RcsEndUserMessageAction").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("label").ToLocalChecked(), LabelGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("RcsEndUserMessageAction").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      RcsEndUserMessageAction(::Windows::ApplicationModel::Chat::RcsEndUserMessageAction^ 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::Chat::RcsEndUserMessageAction^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::RcsEndUserMessageAction^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Chat::RcsEndUserMessageAction^) 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());

      RcsEndUserMessageAction *wrapperInstance = new RcsEndUserMessageAction(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::Chat::RcsEndUserMessageAction^>(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::Chat::RcsEndUserMessageAction^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Chat::RcsEndUserMessageAction^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapRcsEndUserMessageAction(winRtInstance));
    }





    static void LabelGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::RcsEndUserMessageAction^>(info.This())) {
        return;
      }

      RcsEndUserMessageAction *wrapper = RcsEndUserMessageAction::Unwrap<RcsEndUserMessageAction>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->Label;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::ApplicationModel::Chat::RcsEndUserMessageAction^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapRcsEndUserMessageAction(::Windows::ApplicationModel::Chat::RcsEndUserMessageAction^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::RcsEndUserMessageAction^ UnwrapRcsEndUserMessageAction(Local<Value> value);
  };

  Persistent<FunctionTemplate> RcsEndUserMessageAction::s_constructorTemplate;

  v8::Local<v8::Value> WrapRcsEndUserMessageAction(::Windows::ApplicationModel::Chat::RcsEndUserMessageAction^ 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>(RcsEndUserMessageAction::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Chat::RcsEndUserMessageAction^ UnwrapRcsEndUserMessageAction(Local<Value> value) {
     return RcsEndUserMessageAction::Unwrap<RcsEndUserMessageAction>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitRcsEndUserMessageAction(Local<Object> exports) {
    RcsEndUserMessageAction::Init(exports);
  }

  class RcsEndUserMessage : 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>("RcsEndUserMessage").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);

        Local<Function> func;
        Local<FunctionTemplate> funcTemplate;


          
            Nan::SetPrototypeMethod(localRef, "sendResponseAsync", SendResponseAsync);
            Nan::SetPrototypeMethod(localRef, "sendResponseWithPinAsync", SendResponseWithPinAsync);
          


          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("actions").ToLocalChecked(), ActionsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isPinRequired").ToLocalChecked(), IsPinRequiredGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("text").ToLocalChecked(), TextGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("title").ToLocalChecked(), TitleGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("transportId").ToLocalChecked(), TransportIdGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("RcsEndUserMessage").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      RcsEndUserMessage(::Windows::ApplicationModel::Chat::RcsEndUserMessage^ 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::Chat::RcsEndUserMessage^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::RcsEndUserMessage^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Chat::RcsEndUserMessage^) 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());

      RcsEndUserMessage *wrapperInstance = new RcsEndUserMessage(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::Chat::RcsEndUserMessage^>(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::Chat::RcsEndUserMessage^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Chat::RcsEndUserMessage^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapRcsEndUserMessage(winRtInstance));
    }

    static void SendResponseAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::RcsEndUserMessage^>(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;
      }

      RcsEndUserMessage *wrapper = RcsEndUserMessage::Unwrap<RcsEndUserMessage>(info.This());

      ::Windows::Foundation::IAsyncAction^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::RcsEndUserMessageAction^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Chat::RcsEndUserMessageAction^ arg0 = UnwrapRcsEndUserMessageAction(info[0]);
          
          op = wrapper->_instance->SendResponseAsync(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 SendResponseWithPinAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::RcsEndUserMessage^>(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;
      }

      RcsEndUserMessage *wrapper = RcsEndUserMessage::Unwrap<RcsEndUserMessage>(info.This());

      ::Windows::Foundation::IAsyncAction^ op;


      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::RcsEndUserMessageAction^>(info[0])
        && info[1]->IsString())
      {
        try
        {
          ::Windows::ApplicationModel::Chat::RcsEndUserMessageAction^ arg0 = UnwrapRcsEndUserMessageAction(info[0]);
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          
          op = wrapper->_instance->SendResponseWithPinAsync(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<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 ActionsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::RcsEndUserMessage^>(info.This())) {
        return;
      }

      RcsEndUserMessage *wrapper = RcsEndUserMessage::Unwrap<RcsEndUserMessage>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Chat::RcsEndUserMessageAction^>^ result = wrapper->_instance->Actions;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::ApplicationModel::Chat::RcsEndUserMessageAction^>::CreateVectorViewWrapper(result, 
            [](::Windows::ApplicationModel::Chat::RcsEndUserMessageAction^ val) -> Local<Value> {
              return WrapRcsEndUserMessageAction(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::RcsEndUserMessageAction^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Chat::RcsEndUserMessageAction^ {
              return UnwrapRcsEndUserMessageAction(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsPinRequiredGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::RcsEndUserMessage^>(info.This())) {
        return;
      }

      RcsEndUserMessage *wrapper = RcsEndUserMessage::Unwrap<RcsEndUserMessage>(info.This());

      try  {
        bool result = wrapper->_instance->IsPinRequired;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        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::Chat::RcsEndUserMessage^>(info.This())) {
        return;
      }

      RcsEndUserMessage *wrapper = RcsEndUserMessage::Unwrap<RcsEndUserMessage>(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 TitleGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::RcsEndUserMessage^>(info.This())) {
        return;
      }

      RcsEndUserMessage *wrapper = RcsEndUserMessage::Unwrap<RcsEndUserMessage>(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 TransportIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::RcsEndUserMessage^>(info.This())) {
        return;
      }

      RcsEndUserMessage *wrapper = RcsEndUserMessage::Unwrap<RcsEndUserMessage>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->TransportId;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::ApplicationModel::Chat::RcsEndUserMessage^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapRcsEndUserMessage(::Windows::ApplicationModel::Chat::RcsEndUserMessage^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::RcsEndUserMessage^ UnwrapRcsEndUserMessage(Local<Value> value);
  };

  Persistent<FunctionTemplate> RcsEndUserMessage::s_constructorTemplate;

  v8::Local<v8::Value> WrapRcsEndUserMessage(::Windows::ApplicationModel::Chat::RcsEndUserMessage^ 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>(RcsEndUserMessage::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Chat::RcsEndUserMessage^ UnwrapRcsEndUserMessage(Local<Value> value) {
     return RcsEndUserMessage::Unwrap<RcsEndUserMessage>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitRcsEndUserMessage(Local<Object> exports) {
    RcsEndUserMessage::Init(exports);
  }

  class ChatMessageManager : 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>("ChatMessageManager").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, "showSmsSettings", ShowSmsSettings);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(RequestSyncManagerAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("requestSyncManagerAsync").ToLocalChecked(), func);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(RegisterTransportAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("registerTransportAsync").ToLocalChecked(), func);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(GetTransportAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("getTransportAsync").ToLocalChecked(), func);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(GetTransportsAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("getTransportsAsync").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>(ShowComposeSmsMessageAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("showComposeSmsMessageAsync").ToLocalChecked(), func);


        Nan::Set(exports, Nan::New<String>("ChatMessageManager").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ChatMessageManager(::Windows::ApplicationModel::Chat::ChatMessageManager^ 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::Chat::ChatMessageManager^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::ChatMessageManager^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Chat::ChatMessageManager^) 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());

      ChatMessageManager *wrapperInstance = new ChatMessageManager(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::Chat::ChatMessageManager^>(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::Chat::ChatMessageManager^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Chat::ChatMessageManager^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapChatMessageManager(winRtInstance));
    }




    static void RequestSyncManagerAsync(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::Chat::ChatSyncManager^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = ::Windows::ApplicationModel::Chat::ChatMessageManager::RequestSyncManagerAsync();
        } 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::Chat::ChatSyncManager^> t)
      {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapChatSyncManager(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 RegisterTransportAsync(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<::Platform::String^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = ::Windows::ApplicationModel::Chat::ChatMessageManager::RegisterTransportAsync();
        } 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<::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::Utils::NewString(result->Data());
              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 GetTransportAsync(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::Chat::ChatMessageTransport^>^ op;


      if (info.Length() == 2
          && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
            
          op = ::Windows::ApplicationModel::Chat::ChatMessageManager::GetTransportAsync(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::Chat::ChatMessageTransport^> t)
      {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapChatMessageTransport(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 GetTransportsAsync(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::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Chat::ChatMessageTransport^>^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = ::Windows::ApplicationModel::Chat::ChatMessageManager::GetTransportsAsync();
        } 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::Chat::ChatMessageTransport^>^> 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::Chat::ChatMessageTransport^>::CreateVectorViewWrapper(result, 
            [](::Windows::ApplicationModel::Chat::ChatMessageTransport^ val) -> Local<Value> {
              return WrapChatMessageTransport(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::ChatMessageTransport^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Chat::ChatMessageTransport^ {
              return UnwrapChatMessageTransport(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 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::Chat::ChatMessageStore^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = ::Windows::ApplicationModel::Chat::ChatMessageManager::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::Chat::ChatMessageStore^> t)
      {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapChatMessageStore(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 ShowComposeSmsMessageAsync(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::IAsyncAction^ op;


      if (info.Length() == 2
          && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::ChatMessage^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Chat::ChatMessage^ arg0 = UnwrapChatMessage(info[0]);
            
          op = ::Windows::ApplicationModel::Chat::ChatMessageManager::ShowComposeSmsMessageAsync(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 ShowSmsSettings(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::ApplicationModel::Chat::ChatMessageManager::ShowSmsSettings();
          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::Chat::ChatMessageManager^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapChatMessageManager(::Windows::ApplicationModel::Chat::ChatMessageManager^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::ChatMessageManager^ UnwrapChatMessageManager(Local<Value> value);
  };

  Persistent<FunctionTemplate> ChatMessageManager::s_constructorTemplate;

  v8::Local<v8::Value> WrapChatMessageManager(::Windows::ApplicationModel::Chat::ChatMessageManager^ 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>(ChatMessageManager::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Chat::ChatMessageManager^ UnwrapChatMessageManager(Local<Value> value) {
     return ChatMessageManager::Unwrap<ChatMessageManager>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitChatMessageManager(Local<Object> exports) {
    ChatMessageManager::Init(exports);
  }

  class ChatMessageNotificationTriggerDetails : 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>("ChatMessageNotificationTriggerDetails").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("chatMessage").ToLocalChecked(), ChatMessageGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("shouldDisplayToast").ToLocalChecked(), ShouldDisplayToastGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("shouldUpdateActionCenter").ToLocalChecked(), ShouldUpdateActionCenterGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("shouldUpdateBadge").ToLocalChecked(), ShouldUpdateBadgeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("shouldUpdateDetailText").ToLocalChecked(), ShouldUpdateDetailTextGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("ChatMessageNotificationTriggerDetails").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ChatMessageNotificationTriggerDetails(::Windows::ApplicationModel::Chat::ChatMessageNotificationTriggerDetails^ 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::Chat::ChatMessageNotificationTriggerDetails^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::ChatMessageNotificationTriggerDetails^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Chat::ChatMessageNotificationTriggerDetails^) 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());

      ChatMessageNotificationTriggerDetails *wrapperInstance = new ChatMessageNotificationTriggerDetails(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::Chat::ChatMessageNotificationTriggerDetails^>(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::Chat::ChatMessageNotificationTriggerDetails^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Chat::ChatMessageNotificationTriggerDetails^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapChatMessageNotificationTriggerDetails(winRtInstance));
    }





    static void ChatMessageGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::ChatMessageNotificationTriggerDetails^>(info.This())) {
        return;
      }

      ChatMessageNotificationTriggerDetails *wrapper = ChatMessageNotificationTriggerDetails::Unwrap<ChatMessageNotificationTriggerDetails>(info.This());

      try  {
        ::Windows::ApplicationModel::Chat::ChatMessage^ result = wrapper->_instance->ChatMessage;
        info.GetReturnValue().Set(WrapChatMessage(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ShouldDisplayToastGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::ChatMessageNotificationTriggerDetails^>(info.This())) {
        return;
      }

      ChatMessageNotificationTriggerDetails *wrapper = ChatMessageNotificationTriggerDetails::Unwrap<ChatMessageNotificationTriggerDetails>(info.This());

      try  {
        bool result = wrapper->_instance->ShouldDisplayToast;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ShouldUpdateActionCenterGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::ChatMessageNotificationTriggerDetails^>(info.This())) {
        return;
      }

      ChatMessageNotificationTriggerDetails *wrapper = ChatMessageNotificationTriggerDetails::Unwrap<ChatMessageNotificationTriggerDetails>(info.This());

      try  {
        bool result = wrapper->_instance->ShouldUpdateActionCenter;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ShouldUpdateBadgeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::ChatMessageNotificationTriggerDetails^>(info.This())) {
        return;
      }

      ChatMessageNotificationTriggerDetails *wrapper = ChatMessageNotificationTriggerDetails::Unwrap<ChatMessageNotificationTriggerDetails>(info.This());

      try  {
        bool result = wrapper->_instance->ShouldUpdateBadge;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ShouldUpdateDetailTextGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::ChatMessageNotificationTriggerDetails^>(info.This())) {
        return;
      }

      ChatMessageNotificationTriggerDetails *wrapper = ChatMessageNotificationTriggerDetails::Unwrap<ChatMessageNotificationTriggerDetails>(info.This());

      try  {
        bool result = wrapper->_instance->ShouldUpdateDetailText;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::ApplicationModel::Chat::ChatMessageNotificationTriggerDetails^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapChatMessageNotificationTriggerDetails(::Windows::ApplicationModel::Chat::ChatMessageNotificationTriggerDetails^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::ChatMessageNotificationTriggerDetails^ UnwrapChatMessageNotificationTriggerDetails(Local<Value> value);
  };

  Persistent<FunctionTemplate> ChatMessageNotificationTriggerDetails::s_constructorTemplate;

  v8::Local<v8::Value> WrapChatMessageNotificationTriggerDetails(::Windows::ApplicationModel::Chat::ChatMessageNotificationTriggerDetails^ 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>(ChatMessageNotificationTriggerDetails::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Chat::ChatMessageNotificationTriggerDetails^ UnwrapChatMessageNotificationTriggerDetails(Local<Value> value) {
     return ChatMessageNotificationTriggerDetails::Unwrap<ChatMessageNotificationTriggerDetails>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitChatMessageNotificationTriggerDetails(Local<Object> exports) {
    ChatMessageNotificationTriggerDetails::Init(exports);
  }

  class ChatMessageBlocking : 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>("ChatMessageBlocking").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);

        Local<Function> func;
        Local<FunctionTemplate> funcTemplate;





        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        func = Nan::GetFunction(Nan::New<FunctionTemplate>(MarkMessageAsBlockedAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("markMessageAsBlockedAsync").ToLocalChecked(), func);


        Nan::Set(exports, Nan::New<String>("ChatMessageBlocking").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ChatMessageBlocking(::Windows::ApplicationModel::Chat::ChatMessageBlocking^ 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::Chat::ChatMessageBlocking^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::ChatMessageBlocking^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Chat::ChatMessageBlocking^) 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());

      ChatMessageBlocking *wrapperInstance = new ChatMessageBlocking(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::Chat::ChatMessageBlocking^>(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::Chat::ChatMessageBlocking^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Chat::ChatMessageBlocking^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapChatMessageBlocking(winRtInstance));
    }




    static void MarkMessageAsBlockedAsync(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::IAsyncAction^ op;


      if (info.Length() == 3
          && info[0]->IsString()
          && info[1]->IsBoolean())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          bool arg1 = Nan::To<bool>(info[1]).FromMaybe(false);
            
          op = ::Windows::ApplicationModel::Chat::ChatMessageBlocking::MarkMessageAsBlockedAsync(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<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::Chat::ChatMessageBlocking^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapChatMessageBlocking(::Windows::ApplicationModel::Chat::ChatMessageBlocking^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::ChatMessageBlocking^ UnwrapChatMessageBlocking(Local<Value> value);
  };

  Persistent<FunctionTemplate> ChatMessageBlocking::s_constructorTemplate;

  v8::Local<v8::Value> WrapChatMessageBlocking(::Windows::ApplicationModel::Chat::ChatMessageBlocking^ 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>(ChatMessageBlocking::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Chat::ChatMessageBlocking^ UnwrapChatMessageBlocking(Local<Value> value) {
     return ChatMessageBlocking::Unwrap<ChatMessageBlocking>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitChatMessageBlocking(Local<Object> exports) {
    ChatMessageBlocking::Init(exports);
  }

  class ChatCapabilitiesManager : 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>("ChatCapabilitiesManager").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);

        Local<Function> func;
        Local<FunctionTemplate> funcTemplate;





        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        func = Nan::GetFunction(Nan::New<FunctionTemplate>(GetCachedCapabilitiesAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("getCachedCapabilitiesAsync").ToLocalChecked(), func);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(GetCapabilitiesFromNetworkAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("getCapabilitiesFromNetworkAsync").ToLocalChecked(), func);


        Nan::Set(exports, Nan::New<String>("ChatCapabilitiesManager").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ChatCapabilitiesManager(::Windows::ApplicationModel::Chat::ChatCapabilitiesManager^ 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::Chat::ChatCapabilitiesManager^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::ChatCapabilitiesManager^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Chat::ChatCapabilitiesManager^) 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());

      ChatCapabilitiesManager *wrapperInstance = new ChatCapabilitiesManager(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::Chat::ChatCapabilitiesManager^>(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::Chat::ChatCapabilitiesManager^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Chat::ChatCapabilitiesManager^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapChatCapabilitiesManager(winRtInstance));
    }




    static void GetCachedCapabilitiesAsync(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::Chat::ChatCapabilities^>^ op;


      if (info.Length() == 2
          && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
            
          op = ::Windows::ApplicationModel::Chat::ChatCapabilitiesManager::GetCachedCapabilitiesAsync(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::Chat::ChatCapabilities^> t)
      {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapChatCapabilities(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 GetCapabilitiesFromNetworkAsync(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::Chat::ChatCapabilities^>^ op;


      if (info.Length() == 2
          && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
            
          op = ::Windows::ApplicationModel::Chat::ChatCapabilitiesManager::GetCapabilitiesFromNetworkAsync(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::Chat::ChatCapabilities^> t)
      {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapChatCapabilities(result);
              if (tryCatch.HasCaught())
              {
                error = Nan::To<Object>(tryCatch.Exception()).ToLocalChecked();
              }
              else
              {
                error = Undefined();
              }
              if (arg1.IsEmpty()) arg1 = Undefined();
            }
            Local<Value> args[] = {error, arg1};


            invokeCallback(_countof(args), args);
          });
        }
        catch (Platform::Exception^ exception)
        {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {

            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

            Local<Value> args[] = {error};
            invokeCallback(_countof(args), args);
          });
        }
      });
    }




    private:
      ::Windows::ApplicationModel::Chat::ChatCapabilitiesManager^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapChatCapabilitiesManager(::Windows::ApplicationModel::Chat::ChatCapabilitiesManager^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::ChatCapabilitiesManager^ UnwrapChatCapabilitiesManager(Local<Value> value);
  };

  Persistent<FunctionTemplate> ChatCapabilitiesManager::s_constructorTemplate;

  v8::Local<v8::Value> WrapChatCapabilitiesManager(::Windows::ApplicationModel::Chat::ChatCapabilitiesManager^ 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>(ChatCapabilitiesManager::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Chat::ChatCapabilitiesManager^ UnwrapChatCapabilitiesManager(Local<Value> value) {
     return ChatCapabilitiesManager::Unwrap<ChatCapabilitiesManager>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitChatCapabilitiesManager(Local<Object> exports) {
    ChatCapabilitiesManager::Init(exports);
  }

  class RcsManager : 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>("RcsManager").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, "getEndUserMessageManager", GetEndUserMessageManager);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(GetTransportsAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("getTransportsAsync").ToLocalChecked(), func);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(GetTransportAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("getTransportAsync").ToLocalChecked(), func);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(LeaveConversationAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("leaveConversationAsync").ToLocalChecked(), func);


        Nan::Set(exports, Nan::New<String>("RcsManager").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      RcsManager(::Windows::ApplicationModel::Chat::RcsManager^ 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::Chat::RcsManager^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::RcsManager^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Chat::RcsManager^) 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());

      RcsManager *wrapperInstance = new RcsManager(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::Chat::RcsManager^>(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::Chat::RcsManager^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Chat::RcsManager^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapRcsManager(winRtInstance));
    }




    static void GetTransportsAsync(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::Foundation::Collections::IVectorView<::Windows::ApplicationModel::Chat::RcsTransport^>^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = ::Windows::ApplicationModel::Chat::RcsManager::GetTransportsAsync();
        } 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::Chat::RcsTransport^>^> 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::Chat::RcsTransport^>::CreateVectorViewWrapper(result, 
            [](::Windows::ApplicationModel::Chat::RcsTransport^ val) -> Local<Value> {
              return WrapRcsTransport(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::RcsTransport^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Chat::RcsTransport^ {
              return UnwrapRcsTransport(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 GetTransportAsync(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::Chat::RcsTransport^>^ op;


      if (info.Length() == 2
          && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
            
          op = ::Windows::ApplicationModel::Chat::RcsManager::GetTransportAsync(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::Chat::RcsTransport^> t)
      {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapRcsTransport(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 LeaveConversationAsync(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::IAsyncAction^ op;


      if (info.Length() == 2
          && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::ChatConversation^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::Chat::ChatConversation^ arg0 = UnwrapChatConversation(info[0]);
            
          op = ::Windows::ApplicationModel::Chat::RcsManager::LeaveConversationAsync(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 GetEndUserMessageManager(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::ApplicationModel::Chat::RcsEndUserMessageManager^ result;
          result = ::Windows::ApplicationModel::Chat::RcsManager::GetEndUserMessageManager();
          info.GetReturnValue().Set(WrapRcsEndUserMessageManager(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::Chat::RcsManager^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapRcsManager(::Windows::ApplicationModel::Chat::RcsManager^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::RcsManager^ UnwrapRcsManager(Local<Value> value);
  };

  Persistent<FunctionTemplate> RcsManager::s_constructorTemplate;

  v8::Local<v8::Value> WrapRcsManager(::Windows::ApplicationModel::Chat::RcsManager^ 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>(RcsManager::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Chat::RcsManager^ UnwrapRcsManager(Local<Value> value) {
     return RcsManager::Unwrap<RcsManager>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitRcsManager(Local<Object> exports) {
    RcsManager::Init(exports);
  }

  class RcsEndUserMessageAvailableTriggerDetails : 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>("RcsEndUserMessageAvailableTriggerDetails").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("text").ToLocalChecked(), TextGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("title").ToLocalChecked(), TitleGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("RcsEndUserMessageAvailableTriggerDetails").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      RcsEndUserMessageAvailableTriggerDetails(::Windows::ApplicationModel::Chat::RcsEndUserMessageAvailableTriggerDetails^ 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::Chat::RcsEndUserMessageAvailableTriggerDetails^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::RcsEndUserMessageAvailableTriggerDetails^>(info[0])) {
        try {
          winRtInstance = (::Windows::ApplicationModel::Chat::RcsEndUserMessageAvailableTriggerDetails^) 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());

      RcsEndUserMessageAvailableTriggerDetails *wrapperInstance = new RcsEndUserMessageAvailableTriggerDetails(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::Chat::RcsEndUserMessageAvailableTriggerDetails^>(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::Chat::RcsEndUserMessageAvailableTriggerDetails^ winRtInstance;
      try {
        winRtInstance = (::Windows::ApplicationModel::Chat::RcsEndUserMessageAvailableTriggerDetails^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapRcsEndUserMessageAvailableTriggerDetails(winRtInstance));
    }





    static void TextGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::RcsEndUserMessageAvailableTriggerDetails^>(info.This())) {
        return;
      }

      RcsEndUserMessageAvailableTriggerDetails *wrapper = RcsEndUserMessageAvailableTriggerDetails::Unwrap<RcsEndUserMessageAvailableTriggerDetails>(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 TitleGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Chat::RcsEndUserMessageAvailableTriggerDetails^>(info.This())) {
        return;
      }

      RcsEndUserMessageAvailableTriggerDetails *wrapper = RcsEndUserMessageAvailableTriggerDetails::Unwrap<RcsEndUserMessageAvailableTriggerDetails>(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;
      }
    }
      


    private:
      ::Windows::ApplicationModel::Chat::RcsEndUserMessageAvailableTriggerDetails^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapRcsEndUserMessageAvailableTriggerDetails(::Windows::ApplicationModel::Chat::RcsEndUserMessageAvailableTriggerDetails^ wintRtInstance);
      friend ::Windows::ApplicationModel::Chat::RcsEndUserMessageAvailableTriggerDetails^ UnwrapRcsEndUserMessageAvailableTriggerDetails(Local<Value> value);
  };

  Persistent<FunctionTemplate> RcsEndUserMessageAvailableTriggerDetails::s_constructorTemplate;

  v8::Local<v8::Value> WrapRcsEndUserMessageAvailableTriggerDetails(::Windows::ApplicationModel::Chat::RcsEndUserMessageAvailableTriggerDetails^ 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>(RcsEndUserMessageAvailableTriggerDetails::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::ApplicationModel::Chat::RcsEndUserMessageAvailableTriggerDetails^ UnwrapRcsEndUserMessageAvailableTriggerDetails(Local<Value> value) {
     return RcsEndUserMessageAvailableTriggerDetails::Unwrap<RcsEndUserMessageAvailableTriggerDetails>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitRcsEndUserMessageAvailableTriggerDetails(Local<Object> exports) {
    RcsEndUserMessageAvailableTriggerDetails::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::Chat::InitChatMessageStatusEnum(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatMessageKindEnum(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatMessageOperatorKindEnum(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatMessageChangeTypeEnum(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatMessageValidationStatusEnum(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatConversationThreadingKindEnum(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatStoreChangedEventKindEnum(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatTransportErrorCodeCategoryEnum(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatTransportInterpretedErrorCodeEnum(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatMessageTransportKindEnum(target);
      NodeRT::Windows::ApplicationModel::Chat::InitRcsServiceKindEnum(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatItemKindEnum(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatRestoreHistorySpanEnum(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatMessageTransportConfiguration(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatMessage(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatMessageChange(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatMessageChangeReader(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatMessageAttachment(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatConversationThreadingInfo(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatRecipientDeliveryInfo(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatMessageChangeTracker(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatMessageReader(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatMessageValidationResult(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatMessageStore(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatMessageChangedEventArgs(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatConversation(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatConversationReader(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatQueryOptions(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatSearchReader(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatMessageStoreChangedEventArgs(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatMessageChangedDeferral(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatMessageTransport(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatSyncManager(target);
      NodeRT::Windows::ApplicationModel::Chat::InitIChatItem(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatCapabilities(target);
      NodeRT::Windows::ApplicationModel::Chat::InitRemoteParticipantComposingChangedEventArgs(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatSyncConfiguration(target);
      NodeRT::Windows::ApplicationModel::Chat::InitRcsEndUserMessageManager(target);
      NodeRT::Windows::ApplicationModel::Chat::InitRcsTransport(target);
      NodeRT::Windows::ApplicationModel::Chat::InitRcsTransportConfiguration(target);
      NodeRT::Windows::ApplicationModel::Chat::InitRcsServiceKindSupportedChangedEventArgs(target);
      NodeRT::Windows::ApplicationModel::Chat::InitRcsEndUserMessageAvailableEventArgs(target);
      NodeRT::Windows::ApplicationModel::Chat::InitRcsEndUserMessageAction(target);
      NodeRT::Windows::ApplicationModel::Chat::InitRcsEndUserMessage(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatMessageManager(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatMessageNotificationTriggerDetails(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatMessageBlocking(target);
      NodeRT::Windows::ApplicationModel::Chat::InitChatCapabilitiesManager(target);
      NodeRT::Windows::ApplicationModel::Chat::InitRcsManager(target);
      NodeRT::Windows::ApplicationModel::Chat::InitRcsEndUserMessageAvailableTriggerDetails(target);


  NodeRT::Utils::RegisterNameSpace("Windows.ApplicationModel.Chat", target);
}



NODE_MODULE(binding, init)