// 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 Management { namespace Deployment { 
  v8::Local<v8::Value> WrapDeploymentResult(::Windows::Management::Deployment::DeploymentResult^ wintRtInstance);
  ::Windows::Management::Deployment::DeploymentResult^ UnwrapDeploymentResult(Local<Value> value);
  
  v8::Local<v8::Value> WrapPackageUserInformation(::Windows::Management::Deployment::PackageUserInformation^ wintRtInstance);
  ::Windows::Management::Deployment::PackageUserInformation^ UnwrapPackageUserInformation(Local<Value> value);
  
  v8::Local<v8::Value> WrapPackageVolume(::Windows::Management::Deployment::PackageVolume^ wintRtInstance);
  ::Windows::Management::Deployment::PackageVolume^ UnwrapPackageVolume(Local<Value> value);
  
  v8::Local<v8::Value> WrapPackageManagerDebugSettings(::Windows::Management::Deployment::PackageManagerDebugSettings^ wintRtInstance);
  ::Windows::Management::Deployment::PackageManagerDebugSettings^ UnwrapPackageManagerDebugSettings(Local<Value> value);
  
  v8::Local<v8::Value> WrapPackageManager(::Windows::Management::Deployment::PackageManager^ wintRtInstance);
  ::Windows::Management::Deployment::PackageManager^ UnwrapPackageManager(Local<Value> value);
  



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

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

    Nan::Set(exports, Nan::New<String>("DeploymentProgressState").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("queued").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::DeploymentProgressState::Queued)));
    Nan::Set(enumObject, Nan::New<String>("processing").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::DeploymentProgressState::Processing)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("DeploymentOptions").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::DeploymentOptions::None)));
    Nan::Set(enumObject, Nan::New<String>("forceApplicationShutdown").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::DeploymentOptions::ForceApplicationShutdown)));
    Nan::Set(enumObject, Nan::New<String>("developmentMode").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::DeploymentOptions::DevelopmentMode)));
    Nan::Set(enumObject, Nan::New<String>("installAllResources").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::DeploymentOptions::InstallAllResources)));
    Nan::Set(enumObject, Nan::New<String>("forceTargetApplicationShutdown").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::DeploymentOptions::ForceTargetApplicationShutdown)));
    Nan::Set(enumObject, Nan::New<String>("requiredContentGroupOnly").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::DeploymentOptions::RequiredContentGroupOnly)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("RemovalOptions").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::RemovalOptions::None)));
    Nan::Set(enumObject, Nan::New<String>("preserveApplicationData").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::RemovalOptions::PreserveApplicationData)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("PackageTypes").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::PackageTypes::None)));
    Nan::Set(enumObject, Nan::New<String>("main").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::PackageTypes::Main)));
    Nan::Set(enumObject, Nan::New<String>("framework").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::PackageTypes::Framework)));
    Nan::Set(enumObject, Nan::New<String>("resource").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::PackageTypes::Resource)));
    Nan::Set(enumObject, Nan::New<String>("bundle").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::PackageTypes::Bundle)));
    Nan::Set(enumObject, Nan::New<String>("xap").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::PackageTypes::Xap)));
    Nan::Set(enumObject, Nan::New<String>("optional").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::PackageTypes::Optional)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("PackageInstallState").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("notInstalled").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::PackageInstallState::NotInstalled)));
    Nan::Set(enumObject, Nan::New<String>("staged").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::PackageInstallState::Staged)));
    Nan::Set(enumObject, Nan::New<String>("installed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::PackageInstallState::Installed)));
    Nan::Set(enumObject, Nan::New<String>("paused").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::PackageInstallState::Paused)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("PackageState").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("normal").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::PackageState::Normal)));
    Nan::Set(enumObject, Nan::New<String>("licenseInvalid").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::PackageState::LicenseInvalid)));
    Nan::Set(enumObject, Nan::New<String>("modified").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::PackageState::Modified)));
    Nan::Set(enumObject, Nan::New<String>("tampered").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::PackageState::Tampered)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("PackageStatus").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("oK").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::PackageStatus::OK)));
    Nan::Set(enumObject, Nan::New<String>("licenseIssue").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::PackageStatus::LicenseIssue)));
    Nan::Set(enumObject, Nan::New<String>("modified").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::PackageStatus::Modified)));
    Nan::Set(enumObject, Nan::New<String>("tampered").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::PackageStatus::Tampered)));
    Nan::Set(enumObject, Nan::New<String>("disabled").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::PackageStatus::Disabled)));
  }

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

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

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

  ::Windows::Management::Deployment::DeploymentProgress DeploymentProgressFromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::Management::Deployment::DeploymentProgress returnValue;

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

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

    symbol = Nan::New<String>("state").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.state = static_cast<::Windows::Management::Deployment::DeploymentProgressState>(Nan::To<int32_t>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0));
    }
    
    symbol = Nan::New<String>("percentage").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.percentage = static_cast<unsigned int>(Nan::To<uint32_t>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0));
    }
    
    return returnValue;
  }

  Local<Value> DeploymentProgressToJsObject(::Windows::Management::Deployment::DeploymentProgress value) {
    EscapableHandleScope scope;

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

    Nan::Set(obj, Nan::New<String>("state").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(value.state)));
    Nan::Set(obj, Nan::New<String>("percentage").ToLocalChecked(), Nan::New<Integer>(value.percentage));

    return scope.Escape(obj);
  }


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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("activityId").ToLocalChecked(), ActivityIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("errorText").ToLocalChecked(), ErrorTextGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("extendedErrorCode").ToLocalChecked(), ExtendedErrorCodeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isRegistered").ToLocalChecked(), IsRegisteredGetter);

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



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

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

    private:

      DeploymentResult(::Windows::Management::Deployment::DeploymentResult^ 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::Management::Deployment::DeploymentResult^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::DeploymentResult^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::DeploymentResult^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::DeploymentResult^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::DeploymentResult^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Management::Deployment::DeploymentResult^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapDeploymentResult(::Windows::Management::Deployment::DeploymentResult^ wintRtInstance);
      friend ::Windows::Management::Deployment::DeploymentResult^ UnwrapDeploymentResult(Local<Value> value);
  };

  Persistent<FunctionTemplate> DeploymentResult::s_constructorTemplate;

  v8::Local<v8::Value> WrapDeploymentResult(::Windows::Management::Deployment::DeploymentResult^ 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>(DeploymentResult::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Management::Deployment::DeploymentResult^ UnwrapDeploymentResult(Local<Value> value) {
     return DeploymentResult::Unwrap<DeploymentResult>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitDeploymentResult(Local<Object> exports) {
    DeploymentResult::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("installState").ToLocalChecked(), InstallStateGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("userSecurityId").ToLocalChecked(), UserSecurityIdGetter);

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



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

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

    private:

      PackageUserInformation(::Windows::Management::Deployment::PackageUserInformation^ 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::Management::Deployment::PackageUserInformation^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageUserInformation^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageUserInformation^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Management::Deployment::PackageUserInformation^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPackageUserInformation(::Windows::Management::Deployment::PackageUserInformation^ wintRtInstance);
      friend ::Windows::Management::Deployment::PackageUserInformation^ UnwrapPackageUserInformation(Local<Value> value);
  };

  Persistent<FunctionTemplate> PackageUserInformation::s_constructorTemplate;

  v8::Local<v8::Value> WrapPackageUserInformation(::Windows::Management::Deployment::PackageUserInformation^ 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>(PackageUserInformation::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Management::Deployment::PackageUserInformation^ UnwrapPackageUserInformation(Local<Value> value) {
     return PackageUserInformation::Unwrap<PackageUserInformation>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPackageUserInformation(Local<Object> exports) {
    PackageUserInformation::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "findPackages", FindPackages);
            Nan::SetPrototypeMethod(localRef, "findPackagesWithPackageTypes", FindPackagesWithPackageTypes);
            Nan::SetPrototypeMethod(localRef, "findPackage", FindPackage);
            Nan::SetPrototypeMethod(localRef, "findPackagesForUser", FindPackagesForUser);
            Nan::SetPrototypeMethod(localRef, "findPackagesForUserWithPackageTypes", FindPackagesForUserWithPackageTypes);
            Nan::SetPrototypeMethod(localRef, "findPackageForUser", FindPackageForUser);
          

          
            Nan::SetPrototypeMethod(localRef, "getAvailableSpaceAsync", GetAvailableSpaceAsync);
          


          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isOffline").ToLocalChecked(), IsOfflineGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isSystemVolume").ToLocalChecked(), IsSystemVolumeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("mountPoint").ToLocalChecked(), MountPointGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("name").ToLocalChecked(), NameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("packageStorePath").ToLocalChecked(), PackageStorePathGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("supportsHardLinks").ToLocalChecked(), SupportsHardLinksGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isAppxInstallSupported").ToLocalChecked(), IsAppxInstallSupportedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isFullTrustPackageSupported").ToLocalChecked(), IsFullTrustPackageSupportedGetter);

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



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

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

    private:

      PackageVolume(::Windows::Management::Deployment::PackageVolume^ 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::Management::Deployment::PackageVolume^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<unsigned __int64>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->GetAvailableSpaceAsync();
        }
        catch (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<unsigned __int64> 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<Number>(static_cast<double>(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 FindPackages(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVector<::Windows::ApplicationModel::Package^>^ result;
          result = wrapper->_instance->FindPackages();
          info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::ApplicationModel::Package^>::CreateVectorWrapper(result, 
            [](::Windows::ApplicationModel::Package^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "Package", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Package^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Package^ {
              return dynamic_cast<::Windows::ApplicationModel::Package^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && info[0]->IsString()
        && info[1]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          
          ::Windows::Foundation::Collections::IVector<::Windows::ApplicationModel::Package^>^ result;
          result = wrapper->_instance->FindPackages(arg0, arg1);
          info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::ApplicationModel::Package^>::CreateVectorWrapper(result, 
            [](::Windows::ApplicationModel::Package^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "Package", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Package^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Package^ {
              return dynamic_cast<::Windows::ApplicationModel::Package^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          ::Windows::Foundation::Collections::IVector<::Windows::ApplicationModel::Package^>^ result;
          result = wrapper->_instance->FindPackages(arg0);
          info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::ApplicationModel::Package^>::CreateVectorWrapper(result, 
            [](::Windows::ApplicationModel::Package^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "Package", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Package^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Package^ {
              return dynamic_cast<::Windows::ApplicationModel::Package^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void FindPackagesWithPackageTypes(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::Management::Deployment::PackageTypes arg0 = static_cast<::Windows::Management::Deployment::PackageTypes>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          ::Windows::Foundation::Collections::IVector<::Windows::ApplicationModel::Package^>^ result;
          result = wrapper->_instance->FindPackagesWithPackageTypes(arg0);
          info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::ApplicationModel::Package^>::CreateVectorWrapper(result, 
            [](::Windows::ApplicationModel::Package^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "Package", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Package^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Package^ {
              return dynamic_cast<::Windows::ApplicationModel::Package^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && info[0]->IsInt32()
        && info[1]->IsString()
        && info[2]->IsString())
      {
        try
        {
          ::Windows::Management::Deployment::PackageTypes arg0 = static_cast<::Windows::Management::Deployment::PackageTypes>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          Platform::String^ arg2 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[2])));
          
          ::Windows::Foundation::Collections::IVector<::Windows::ApplicationModel::Package^>^ result;
          result = wrapper->_instance->FindPackagesWithPackageTypes(arg0, arg1, arg2);
          info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::ApplicationModel::Package^>::CreateVectorWrapper(result, 
            [](::Windows::ApplicationModel::Package^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "Package", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Package^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Package^ {
              return dynamic_cast<::Windows::ApplicationModel::Package^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && info[0]->IsInt32()
        && info[1]->IsString())
      {
        try
        {
          ::Windows::Management::Deployment::PackageTypes arg0 = static_cast<::Windows::Management::Deployment::PackageTypes>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          
          ::Windows::Foundation::Collections::IVector<::Windows::ApplicationModel::Package^>^ result;
          result = wrapper->_instance->FindPackagesWithPackageTypes(arg0, arg1);
          info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::ApplicationModel::Package^>::CreateVectorWrapper(result, 
            [](::Windows::ApplicationModel::Package^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "Package", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Package^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Package^ {
              return dynamic_cast<::Windows::ApplicationModel::Package^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void FindPackage(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          ::Windows::Foundation::Collections::IVector<::Windows::ApplicationModel::Package^>^ result;
          result = wrapper->_instance->FindPackage(arg0);
          info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::ApplicationModel::Package^>::CreateVectorWrapper(result, 
            [](::Windows::ApplicationModel::Package^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "Package", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Package^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Package^ {
              return dynamic_cast<::Windows::ApplicationModel::Package^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void FindPackagesForUser(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          ::Windows::Foundation::Collections::IVector<::Windows::ApplicationModel::Package^>^ result;
          result = wrapper->_instance->FindPackagesForUser(arg0);
          info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::ApplicationModel::Package^>::CreateVectorWrapper(result, 
            [](::Windows::ApplicationModel::Package^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "Package", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Package^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Package^ {
              return dynamic_cast<::Windows::ApplicationModel::Package^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && info[0]->IsString()
        && info[1]->IsString()
        && info[2]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          Platform::String^ arg2 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[2])));
          
          ::Windows::Foundation::Collections::IVector<::Windows::ApplicationModel::Package^>^ result;
          result = wrapper->_instance->FindPackagesForUser(arg0, arg1, arg2);
          info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::ApplicationModel::Package^>::CreateVectorWrapper(result, 
            [](::Windows::ApplicationModel::Package^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "Package", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Package^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Package^ {
              return dynamic_cast<::Windows::ApplicationModel::Package^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && info[0]->IsString()
        && info[1]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          
          ::Windows::Foundation::Collections::IVector<::Windows::ApplicationModel::Package^>^ result;
          result = wrapper->_instance->FindPackagesForUser(arg0, arg1);
          info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::ApplicationModel::Package^>::CreateVectorWrapper(result, 
            [](::Windows::ApplicationModel::Package^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "Package", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Package^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Package^ {
              return dynamic_cast<::Windows::ApplicationModel::Package^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void FindPackagesForUserWithPackageTypes(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(info.This())) {
        return;
      }

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

      if (info.Length() == 2
        && info[0]->IsString()
        && info[1]->IsInt32())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Management::Deployment::PackageTypes arg1 = static_cast<::Windows::Management::Deployment::PackageTypes>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          ::Windows::Foundation::Collections::IVector<::Windows::ApplicationModel::Package^>^ result;
          result = wrapper->_instance->FindPackagesForUserWithPackageTypes(arg0, arg1);
          info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::ApplicationModel::Package^>::CreateVectorWrapper(result, 
            [](::Windows::ApplicationModel::Package^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "Package", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Package^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Package^ {
              return dynamic_cast<::Windows::ApplicationModel::Package^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 4
        && info[0]->IsString()
        && info[1]->IsInt32()
        && info[2]->IsString()
        && info[3]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Management::Deployment::PackageTypes arg1 = static_cast<::Windows::Management::Deployment::PackageTypes>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          Platform::String^ arg2 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[2])));
          Platform::String^ arg3 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[3])));
          
          ::Windows::Foundation::Collections::IVector<::Windows::ApplicationModel::Package^>^ result;
          result = wrapper->_instance->FindPackagesForUserWithPackageTypes(arg0, arg1, arg2, arg3);
          info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::ApplicationModel::Package^>::CreateVectorWrapper(result, 
            [](::Windows::ApplicationModel::Package^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "Package", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Package^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Package^ {
              return dynamic_cast<::Windows::ApplicationModel::Package^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && info[0]->IsString()
        && info[1]->IsInt32()
        && info[2]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Management::Deployment::PackageTypes arg1 = static_cast<::Windows::Management::Deployment::PackageTypes>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          Platform::String^ arg2 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[2])));
          
          ::Windows::Foundation::Collections::IVector<::Windows::ApplicationModel::Package^>^ result;
          result = wrapper->_instance->FindPackagesForUserWithPackageTypes(arg0, arg1, arg2);
          info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::ApplicationModel::Package^>::CreateVectorWrapper(result, 
            [](::Windows::ApplicationModel::Package^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "Package", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Package^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Package^ {
              return dynamic_cast<::Windows::ApplicationModel::Package^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void FindPackageForUser(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(info.This())) {
        return;
      }

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

      if (info.Length() == 2
        && info[0]->IsString()
        && info[1]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          
          ::Windows::Foundation::Collections::IVector<::Windows::ApplicationModel::Package^>^ result;
          result = wrapper->_instance->FindPackageForUser(arg0, arg1);
          info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::ApplicationModel::Package^>::CreateVectorWrapper(result, 
            [](::Windows::ApplicationModel::Package^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "Package", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Package^>(value);
            },
            [](Local<Value> value) -> ::Windows::ApplicationModel::Package^ {
              return dynamic_cast<::Windows::ApplicationModel::Package^>(NodeRT::Utils::GetObjectInstance(value));
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Management::Deployment::PackageVolume^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPackageVolume(::Windows::Management::Deployment::PackageVolume^ wintRtInstance);
      friend ::Windows::Management::Deployment::PackageVolume^ UnwrapPackageVolume(Local<Value> value);
  };

  Persistent<FunctionTemplate> PackageVolume::s_constructorTemplate;

  v8::Local<v8::Value> WrapPackageVolume(::Windows::Management::Deployment::PackageVolume^ 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>(PackageVolume::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Management::Deployment::PackageVolume^ UnwrapPackageVolume(Local<Value> value) {
     return PackageVolume::Unwrap<PackageVolume>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPackageVolume(Local<Object> exports) {
    PackageVolume::Init(exports);
  }

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

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


          
            Nan::SetPrototypeMethod(localRef, "setContentGroupStateAsync", SetContentGroupStateAsync);
          



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



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

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

    private:

      PackageManagerDebugSettings(::Windows::Management::Deployment::PackageManagerDebugSettings^ 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::Management::Deployment::PackageManagerDebugSettings^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManagerDebugSettings^>(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;
      }

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

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


      if (info.Length() == 4
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Package^>(info[0])
        && info[1]->IsString()
        && info[2]->IsInt32())
      {
        try
        {
          ::Windows::ApplicationModel::Package^ arg0 = dynamic_cast<::Windows::ApplicationModel::Package^>(NodeRT::Utils::GetObjectInstance(info[0]));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          ::Windows::ApplicationModel::PackageContentGroupState arg2 = static_cast<::Windows::ApplicationModel::PackageContentGroupState>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          
          op = wrapper->_instance->SetContentGroupStateAsync(arg0,arg1,arg2);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 5
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::Package^>(info[0])
        && info[1]->IsString()
        && info[2]->IsInt32()
        && info[3]->IsNumber())
      {
        try
        {
          ::Windows::ApplicationModel::Package^ arg0 = dynamic_cast<::Windows::ApplicationModel::Package^>(NodeRT::Utils::GetObjectInstance(info[0]));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          ::Windows::ApplicationModel::PackageContentGroupState arg2 = static_cast<::Windows::ApplicationModel::PackageContentGroupState>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          double arg3 = Nan::To<double>(info[3]).FromMaybe(0.0);
          
          op = wrapper->_instance->SetContentGroupStateAsync(arg0,arg1,arg2,arg3);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

      opTask.then( [asyncToken] (task<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::Management::Deployment::PackageManagerDebugSettings^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPackageManagerDebugSettings(::Windows::Management::Deployment::PackageManagerDebugSettings^ wintRtInstance);
      friend ::Windows::Management::Deployment::PackageManagerDebugSettings^ UnwrapPackageManagerDebugSettings(Local<Value> value);
  };

  Persistent<FunctionTemplate> PackageManagerDebugSettings::s_constructorTemplate;

  v8::Local<v8::Value> WrapPackageManagerDebugSettings(::Windows::Management::Deployment::PackageManagerDebugSettings^ 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>(PackageManagerDebugSettings::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Management::Deployment::PackageManagerDebugSettings^ UnwrapPackageManagerDebugSettings(Local<Value> value) {
     return PackageManagerDebugSettings::Unwrap<PackageManagerDebugSettings>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPackageManagerDebugSettings(Local<Object> exports) {
    PackageManagerDebugSettings::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "findPackages", FindPackages);
            Nan::SetPrototypeMethod(localRef, "findPackagesForUser", FindPackagesForUser);
            Nan::SetPrototypeMethod(localRef, "findUsers", FindUsers);
            Nan::SetPrototypeMethod(localRef, "setPackageState", SetPackageState);
            Nan::SetPrototypeMethod(localRef, "findPackage", FindPackage);
            Nan::SetPrototypeMethod(localRef, "findPackageForUser", FindPackageForUser);
            Nan::SetPrototypeMethod(localRef, "findPackagesWithPackageTypes", FindPackagesWithPackageTypes);
            Nan::SetPrototypeMethod(localRef, "findPackagesForUserWithPackageTypes", FindPackagesForUserWithPackageTypes);
            Nan::SetPrototypeMethod(localRef, "clearPackageStatus", ClearPackageStatus);
            Nan::SetPrototypeMethod(localRef, "findPackageVolume", FindPackageVolume);
            Nan::SetPrototypeMethod(localRef, "findPackageVolumes", FindPackageVolumes);
            Nan::SetPrototypeMethod(localRef, "getDefaultPackageVolume", GetDefaultPackageVolume);
            Nan::SetPrototypeMethod(localRef, "setDefaultPackageVolume", SetDefaultPackageVolume);
            Nan::SetPrototypeMethod(localRef, "setPackageStatus", SetPackageStatus);
          

          
            Nan::SetPrototypeMethod(localRef, "addPackageAsync", AddPackageAsync);
            Nan::SetPrototypeMethod(localRef, "updatePackageAsync", UpdatePackageAsync);
            Nan::SetPrototypeMethod(localRef, "removePackageAsync", RemovePackageAsync);
            Nan::SetPrototypeMethod(localRef, "stagePackageAsync", StagePackageAsync);
            Nan::SetPrototypeMethod(localRef, "registerPackageAsync", RegisterPackageAsync);
            Nan::SetPrototypeMethod(localRef, "cleanupPackageForUserAsync", CleanupPackageForUserAsync);
            Nan::SetPrototypeMethod(localRef, "registerPackageByFullNameAsync", RegisterPackageByFullNameAsync);
            Nan::SetPrototypeMethod(localRef, "stageUserDataAsync", StageUserDataAsync);
            Nan::SetPrototypeMethod(localRef, "addPackageVolumeAsync", AddPackageVolumeAsync);
            Nan::SetPrototypeMethod(localRef, "movePackageToVolumeAsync", MovePackageToVolumeAsync);
            Nan::SetPrototypeMethod(localRef, "removePackageVolumeAsync", RemovePackageVolumeAsync);
            Nan::SetPrototypeMethod(localRef, "setPackageVolumeOfflineAsync", SetPackageVolumeOfflineAsync);
            Nan::SetPrototypeMethod(localRef, "setPackageVolumeOnlineAsync", SetPackageVolumeOnlineAsync);
            Nan::SetPrototypeMethod(localRef, "getPackageVolumesAsync", GetPackageVolumesAsync);
            Nan::SetPrototypeMethod(localRef, "registerPackageByFamilyNameAsync", RegisterPackageByFamilyNameAsync);
          


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

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



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

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

    private:

      PackageManager(::Windows::Management::Deployment::PackageManager^ 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::Management::Deployment::PackageManager^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperationWithProgress<::Windows::Management::Deployment::DeploymentResult^, ::Windows::Management::Deployment::DeploymentProgress>^ op;


      if (info.Length() == 4
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(info[0])
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^>(info[1]) || info[1]->IsArray())
        && info[2]->IsInt32())
      {
        try
        {
          ::Windows::Foundation::Uri^ arg0 = dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Foundation::Uri^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Foundation::Uri^ {
                   return dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          ::Windows::Management::Deployment::DeploymentOptions arg2 = static_cast<::Windows::Management::Deployment::DeploymentOptions>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          
          op = wrapper->_instance->AddPackageAsync(arg0,arg1,arg2);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 5
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(info[0])
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^>(info[1]) || info[1]->IsArray())
        && info[2]->IsInt32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(info[3]))
      {
        try
        {
          ::Windows::Foundation::Uri^ arg0 = dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Foundation::Uri^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Foundation::Uri^ {
                   return dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          ::Windows::Management::Deployment::DeploymentOptions arg2 = static_cast<::Windows::Management::Deployment::DeploymentOptions>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          ::Windows::Management::Deployment::PackageVolume^ arg3 = UnwrapPackageVolume(info[3]);
          
          op = wrapper->_instance->AddPackageAsync(arg0,arg1,arg2,arg3);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 7
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(info[0])
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^>(info[1]) || info[1]->IsArray())
        && info[2]->IsInt32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(info[3])
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Platform::String^>^>(info[4]) || info[4]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^>(info[5]) || info[5]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Uri^ arg0 = dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Foundation::Uri^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Foundation::Uri^ {
                   return dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          ::Windows::Management::Deployment::DeploymentOptions arg2 = static_cast<::Windows::Management::Deployment::DeploymentOptions>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          ::Windows::Management::Deployment::PackageVolume^ arg3 = UnwrapPackageVolume(info[3]);
          ::Windows::Foundation::Collections::IIterable<::Platform::String^>^ arg4 = 
            [] (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[4]);
          ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^ arg5 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Foundation::Uri^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Foundation::Uri^ {
                   return dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[5]);
          
          op = wrapper->_instance->AddPackageAsync(arg0,arg1,arg2,arg3,arg4,arg5);
        }
        catch (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::Management::Deployment::DeploymentResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperationWithProgress<::Windows::Management::Deployment::DeploymentResult^, ::Windows::Management::Deployment::DeploymentProgress>^ op;


      if (info.Length() == 4
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(info[0])
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^>(info[1]) || info[1]->IsArray())
        && info[2]->IsInt32())
      {
        try
        {
          ::Windows::Foundation::Uri^ arg0 = dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Foundation::Uri^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Foundation::Uri^ {
                   return dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          ::Windows::Management::Deployment::DeploymentOptions arg2 = static_cast<::Windows::Management::Deployment::DeploymentOptions>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          
          op = wrapper->_instance->UpdatePackageAsync(arg0,arg1,arg2);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperationWithProgress<::Windows::Management::Deployment::DeploymentResult^, ::Windows::Management::Deployment::DeploymentProgress>^ 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->RemovePackageAsync(arg0);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && info[0]->IsString()
        && info[1]->IsInt32())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Management::Deployment::RemovalOptions arg1 = static_cast<::Windows::Management::Deployment::RemovalOptions>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          op = wrapper->_instance->RemovePackageAsync(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::Management::Deployment::DeploymentResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperationWithProgress<::Windows::Management::Deployment::DeploymentResult^, ::Windows::Management::Deployment::DeploymentProgress>^ op;


      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(info[0])
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^>(info[1]) || info[1]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Uri^ arg0 = dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Foundation::Uri^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Foundation::Uri^ {
                   return dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          
          op = wrapper->_instance->StagePackageAsync(arg0,arg1);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 4
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(info[0])
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^>(info[1]) || info[1]->IsArray())
        && info[2]->IsInt32())
      {
        try
        {
          ::Windows::Foundation::Uri^ arg0 = dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Foundation::Uri^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Foundation::Uri^ {
                   return dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          ::Windows::Management::Deployment::DeploymentOptions arg2 = static_cast<::Windows::Management::Deployment::DeploymentOptions>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          
          op = wrapper->_instance->StagePackageAsync(arg0,arg1,arg2);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 5
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(info[0])
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^>(info[1]) || info[1]->IsArray())
        && info[2]->IsInt32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(info[3]))
      {
        try
        {
          ::Windows::Foundation::Uri^ arg0 = dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Foundation::Uri^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Foundation::Uri^ {
                   return dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          ::Windows::Management::Deployment::DeploymentOptions arg2 = static_cast<::Windows::Management::Deployment::DeploymentOptions>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          ::Windows::Management::Deployment::PackageVolume^ arg3 = UnwrapPackageVolume(info[3]);
          
          op = wrapper->_instance->StagePackageAsync(arg0,arg1,arg2,arg3);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 7
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(info[0])
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^>(info[1]) || info[1]->IsArray())
        && info[2]->IsInt32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(info[3])
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Platform::String^>^>(info[4]) || info[4]->IsArray())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^>(info[5]) || info[5]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Uri^ arg0 = dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Foundation::Uri^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Foundation::Uri^ {
                   return dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          ::Windows::Management::Deployment::DeploymentOptions arg2 = static_cast<::Windows::Management::Deployment::DeploymentOptions>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          ::Windows::Management::Deployment::PackageVolume^ arg3 = UnwrapPackageVolume(info[3]);
          ::Windows::Foundation::Collections::IIterable<::Platform::String^>^ arg4 = 
            [] (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[4]);
          ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^ arg5 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Foundation::Uri^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Foundation::Uri^ {
                   return dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[5]);
          
          op = wrapper->_instance->StagePackageAsync(arg0,arg1,arg2,arg3,arg4,arg5);
        }
        catch (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::Management::Deployment::DeploymentResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperationWithProgress<::Windows::Management::Deployment::DeploymentResult^, ::Windows::Management::Deployment::DeploymentProgress>^ op;


      if (info.Length() == 4
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(info[0])
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^>(info[1]) || info[1]->IsArray())
        && info[2]->IsInt32())
      {
        try
        {
          ::Windows::Foundation::Uri^ arg0 = dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Foundation::Uri^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Foundation::Uri^ {
                   return dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          ::Windows::Management::Deployment::DeploymentOptions arg2 = static_cast<::Windows::Management::Deployment::DeploymentOptions>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          
          op = wrapper->_instance->RegisterPackageAsync(arg0,arg1,arg2);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 5
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(info[0])
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^>(info[1]) || info[1]->IsArray())
        && info[2]->IsInt32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(info[3]))
      {
        try
        {
          ::Windows::Foundation::Uri^ arg0 = dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Windows::Foundation::Uri^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Foundation::Uri^ {
                   return dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          ::Windows::Management::Deployment::DeploymentOptions arg2 = static_cast<::Windows::Management::Deployment::DeploymentOptions>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          ::Windows::Management::Deployment::PackageVolume^ arg3 = UnwrapPackageVolume(info[3]);
          
          op = wrapper->_instance->RegisterPackageAsync(arg0,arg1,arg2,arg3);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperationWithProgress<::Windows::Management::Deployment::DeploymentResult^, ::Windows::Management::Deployment::DeploymentProgress>^ 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->CleanupPackageForUserAsync(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::Management::Deployment::DeploymentResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperationWithProgress<::Windows::Management::Deployment::DeploymentResult^, ::Windows::Management::Deployment::DeploymentProgress>^ op;


      if (info.Length() == 4
        && info[0]->IsString()
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Platform::String^>^>(info[1]) || info[1]->IsArray())
        && info[2]->IsInt32())
      {
        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]);
          ::Windows::Management::Deployment::DeploymentOptions arg2 = static_cast<::Windows::Management::Deployment::DeploymentOptions>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          
          op = wrapper->_instance->RegisterPackageByFullNameAsync(arg0,arg1,arg2);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperationWithProgress<::Windows::Management::Deployment::DeploymentResult^, ::Windows::Management::Deployment::DeploymentProgress>^ 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->StageUserDataAsync(arg0);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && info[0]->IsString()
        && info[1]->IsInt32())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Management::Deployment::DeploymentOptions arg1 = static_cast<::Windows::Management::Deployment::DeploymentOptions>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          op = wrapper->_instance->StageUserDataAsync(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::Management::Deployment::DeploymentResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(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;
      }

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperationWithProgress<::Windows::Management::Deployment::DeploymentResult^, ::Windows::Management::Deployment::DeploymentProgress>^ op;


      if (info.Length() == 4
        && info[0]->IsString()
        && info[1]->IsInt32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(info[2]))
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Management::Deployment::DeploymentOptions arg1 = static_cast<::Windows::Management::Deployment::DeploymentOptions>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          ::Windows::Management::Deployment::PackageVolume^ arg2 = UnwrapPackageVolume(info[2]);
          
          op = wrapper->_instance->MovePackageToVolumeAsync(arg0,arg1,arg2);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperationWithProgress<::Windows::Management::Deployment::DeploymentResult^, ::Windows::Management::Deployment::DeploymentProgress>^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(info[0]))
      {
        try
        {
          ::Windows::Management::Deployment::PackageVolume^ arg0 = UnwrapPackageVolume(info[0]);
          
          op = wrapper->_instance->RemovePackageVolumeAsync(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::Management::Deployment::DeploymentResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperationWithProgress<::Windows::Management::Deployment::DeploymentResult^, ::Windows::Management::Deployment::DeploymentProgress>^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(info[0]))
      {
        try
        {
          ::Windows::Management::Deployment::PackageVolume^ arg0 = UnwrapPackageVolume(info[0]);
          
          op = wrapper->_instance->SetPackageVolumeOfflineAsync(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::Management::Deployment::DeploymentResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperationWithProgress<::Windows::Management::Deployment::DeploymentResult^, ::Windows::Management::Deployment::DeploymentProgress>^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(info[0]))
      {
        try
        {
          ::Windows::Management::Deployment::PackageVolume^ arg0 = UnwrapPackageVolume(info[0]);
          
          op = wrapper->_instance->SetPackageVolumeOnlineAsync(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::Management::Deployment::DeploymentResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Foundation::Collections::IVectorView<::Windows::Management::Deployment::PackageVolume^>^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->GetPackageVolumesAsync();
        }
        catch (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::Management::Deployment::PackageVolume^>^> 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::Management::Deployment::PackageVolume^>::CreateVectorViewWrapper(result, 
            [](::Windows::Management::Deployment::PackageVolume^ val) -> Local<Value> {
              return WrapPackageVolume(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(value);
            },
            [](Local<Value> value) -> ::Windows::Management::Deployment::PackageVolume^ {
              return UnwrapPackageVolume(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 RegisterPackageByFamilyNameAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperationWithProgress<::Windows::Management::Deployment::DeploymentResult^, ::Windows::Management::Deployment::DeploymentProgress>^ op;


      if (info.Length() == 6
        && info[0]->IsString()
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Platform::String^>^>(info[1]) || info[1]->IsArray())
        && info[2]->IsInt32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(info[3])
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Platform::String^>^>(info[4]) || info[4]->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]);
          ::Windows::Management::Deployment::DeploymentOptions arg2 = static_cast<::Windows::Management::Deployment::DeploymentOptions>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          ::Windows::Management::Deployment::PackageVolume^ arg3 = UnwrapPackageVolume(info[3]);
          ::Windows::Foundation::Collections::IIterable<::Platform::String^>^ arg4 = 
            [] (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[4]);
          
          op = wrapper->_instance->RegisterPackageByFamilyNameAsync(arg0,arg1,arg2,arg3,arg4);
        }
        catch (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::Management::Deployment::DeploymentResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<::Windows::ApplicationModel::Package^>^ result;
          result = wrapper->_instance->FindPackages();
          info.GetReturnValue().Set(NodeRT::Collections::IterableWrapper<::Windows::ApplicationModel::Package^>::CreateIterableWrapper(result, 
            [](::Windows::ApplicationModel::Package^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "Package", val);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && info[0]->IsString()
        && info[1]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          
          ::Windows::Foundation::Collections::IIterable<::Windows::ApplicationModel::Package^>^ result;
          result = wrapper->_instance->FindPackages(arg0, arg1);
          info.GetReturnValue().Set(NodeRT::Collections::IterableWrapper<::Windows::ApplicationModel::Package^>::CreateIterableWrapper(result, 
            [](::Windows::ApplicationModel::Package^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "Package", val);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          ::Windows::Foundation::Collections::IIterable<::Windows::ApplicationModel::Package^>^ result;
          result = wrapper->_instance->FindPackages(arg0);
          info.GetReturnValue().Set(NodeRT::Collections::IterableWrapper<::Windows::ApplicationModel::Package^>::CreateIterableWrapper(result, 
            [](::Windows::ApplicationModel::Package^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "Package", val);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void FindPackagesForUser(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          ::Windows::Foundation::Collections::IIterable<::Windows::ApplicationModel::Package^>^ result;
          result = wrapper->_instance->FindPackagesForUser(arg0);
          info.GetReturnValue().Set(NodeRT::Collections::IterableWrapper<::Windows::ApplicationModel::Package^>::CreateIterableWrapper(result, 
            [](::Windows::ApplicationModel::Package^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "Package", val);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && info[0]->IsString()
        && info[1]->IsString()
        && info[2]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          Platform::String^ arg2 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[2])));
          
          ::Windows::Foundation::Collections::IIterable<::Windows::ApplicationModel::Package^>^ result;
          result = wrapper->_instance->FindPackagesForUser(arg0, arg1, arg2);
          info.GetReturnValue().Set(NodeRT::Collections::IterableWrapper<::Windows::ApplicationModel::Package^>::CreateIterableWrapper(result, 
            [](::Windows::ApplicationModel::Package^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "Package", val);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && info[0]->IsString()
        && info[1]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          
          ::Windows::Foundation::Collections::IIterable<::Windows::ApplicationModel::Package^>^ result;
          result = wrapper->_instance->FindPackagesForUser(arg0, arg1);
          info.GetReturnValue().Set(NodeRT::Collections::IterableWrapper<::Windows::ApplicationModel::Package^>::CreateIterableWrapper(result, 
            [](::Windows::ApplicationModel::Package^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "Package", val);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void FindUsers(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          ::Windows::Foundation::Collections::IIterable<::Windows::Management::Deployment::PackageUserInformation^>^ result;
          result = wrapper->_instance->FindUsers(arg0);
          info.GetReturnValue().Set(NodeRT::Collections::IterableWrapper<::Windows::Management::Deployment::PackageUserInformation^>::CreateIterableWrapper(result, 
            [](::Windows::Management::Deployment::PackageUserInformation^ val) -> Local<Value> {
              return WrapPackageUserInformation(val);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void SetPackageState(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(info.This())) {
        return;
      }

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

      if (info.Length() == 2
        && info[0]->IsString()
        && info[1]->IsInt32())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Management::Deployment::PackageState arg1 = static_cast<::Windows::Management::Deployment::PackageState>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          wrapper->_instance->SetPackageState(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void FindPackage(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          ::Windows::ApplicationModel::Package^ result;
          result = wrapper->_instance->FindPackage(arg0);
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "Package", 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 FindPackageForUser(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(info.This())) {
        return;
      }

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

      if (info.Length() == 2
        && info[0]->IsString()
        && info[1]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          
          ::Windows::ApplicationModel::Package^ result;
          result = wrapper->_instance->FindPackageForUser(arg0, arg1);
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "Package", 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 FindPackagesWithPackageTypes(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::Management::Deployment::PackageTypes arg0 = static_cast<::Windows::Management::Deployment::PackageTypes>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          ::Windows::Foundation::Collections::IIterable<::Windows::ApplicationModel::Package^>^ result;
          result = wrapper->_instance->FindPackagesWithPackageTypes(arg0);
          info.GetReturnValue().Set(NodeRT::Collections::IterableWrapper<::Windows::ApplicationModel::Package^>::CreateIterableWrapper(result, 
            [](::Windows::ApplicationModel::Package^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "Package", val);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && info[0]->IsString()
        && info[1]->IsString()
        && info[2]->IsInt32())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          ::Windows::Management::Deployment::PackageTypes arg2 = static_cast<::Windows::Management::Deployment::PackageTypes>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          
          ::Windows::Foundation::Collections::IIterable<::Windows::ApplicationModel::Package^>^ result;
          result = wrapper->_instance->FindPackagesWithPackageTypes(arg0, arg1, arg2);
          info.GetReturnValue().Set(NodeRT::Collections::IterableWrapper<::Windows::ApplicationModel::Package^>::CreateIterableWrapper(result, 
            [](::Windows::ApplicationModel::Package^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "Package", val);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && info[0]->IsString()
        && info[1]->IsInt32())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Management::Deployment::PackageTypes arg1 = static_cast<::Windows::Management::Deployment::PackageTypes>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          ::Windows::Foundation::Collections::IIterable<::Windows::ApplicationModel::Package^>^ result;
          result = wrapper->_instance->FindPackagesWithPackageTypes(arg0, arg1);
          info.GetReturnValue().Set(NodeRT::Collections::IterableWrapper<::Windows::ApplicationModel::Package^>::CreateIterableWrapper(result, 
            [](::Windows::ApplicationModel::Package^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "Package", val);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void FindPackagesForUserWithPackageTypes(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(info.This())) {
        return;
      }

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

      if (info.Length() == 2
        && info[0]->IsString()
        && info[1]->IsInt32())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Management::Deployment::PackageTypes arg1 = static_cast<::Windows::Management::Deployment::PackageTypes>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          ::Windows::Foundation::Collections::IIterable<::Windows::ApplicationModel::Package^>^ result;
          result = wrapper->_instance->FindPackagesForUserWithPackageTypes(arg0, arg1);
          info.GetReturnValue().Set(NodeRT::Collections::IterableWrapper<::Windows::ApplicationModel::Package^>::CreateIterableWrapper(result, 
            [](::Windows::ApplicationModel::Package^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "Package", val);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 4
        && info[0]->IsString()
        && info[1]->IsString()
        && info[2]->IsString()
        && info[3]->IsInt32())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          Platform::String^ arg2 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[2])));
          ::Windows::Management::Deployment::PackageTypes arg3 = static_cast<::Windows::Management::Deployment::PackageTypes>(Nan::To<int32_t>(info[3]).FromMaybe(0));
          
          ::Windows::Foundation::Collections::IIterable<::Windows::ApplicationModel::Package^>^ result;
          result = wrapper->_instance->FindPackagesForUserWithPackageTypes(arg0, arg1, arg2, arg3);
          info.GetReturnValue().Set(NodeRT::Collections::IterableWrapper<::Windows::ApplicationModel::Package^>::CreateIterableWrapper(result, 
            [](::Windows::ApplicationModel::Package^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "Package", val);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && info[0]->IsString()
        && info[1]->IsString()
        && info[2]->IsInt32())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          ::Windows::Management::Deployment::PackageTypes arg2 = static_cast<::Windows::Management::Deployment::PackageTypes>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          
          ::Windows::Foundation::Collections::IIterable<::Windows::ApplicationModel::Package^>^ result;
          result = wrapper->_instance->FindPackagesForUserWithPackageTypes(arg0, arg1, arg2);
          info.GetReturnValue().Set(NodeRT::Collections::IterableWrapper<::Windows::ApplicationModel::Package^>::CreateIterableWrapper(result, 
            [](::Windows::ApplicationModel::Package^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.ApplicationModel", "Package", val);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void ClearPackageStatus(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(info.This())) {
        return;
      }

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

      if (info.Length() == 2
        && info[0]->IsString()
        && info[1]->IsInt32())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Management::Deployment::PackageStatus arg1 = static_cast<::Windows::Management::Deployment::PackageStatus>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          wrapper->_instance->ClearPackageStatus(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void FindPackageVolume(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          ::Windows::Management::Deployment::PackageVolume^ result;
          result = wrapper->_instance->FindPackageVolume(arg0);
          info.GetReturnValue().Set(WrapPackageVolume(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 FindPackageVolumes(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<::Windows::Management::Deployment::PackageVolume^>^ result;
          result = wrapper->_instance->FindPackageVolumes();
          info.GetReturnValue().Set(NodeRT::Collections::IterableWrapper<::Windows::Management::Deployment::PackageVolume^>::CreateIterableWrapper(result, 
            [](::Windows::Management::Deployment::PackageVolume^ val) -> Local<Value> {
              return WrapPackageVolume(val);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetDefaultPackageVolume(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Management::Deployment::PackageVolume^ result;
          result = wrapper->_instance->GetDefaultPackageVolume();
          info.GetReturnValue().Set(WrapPackageVolume(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 SetDefaultPackageVolume(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(info[0]))
      {
        try
        {
          ::Windows::Management::Deployment::PackageVolume^ arg0 = UnwrapPackageVolume(info[0]);
          
          wrapper->_instance->SetDefaultPackageVolume(arg0);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void SetPackageStatus(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(info.This())) {
        return;
      }

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

      if (info.Length() == 2
        && info[0]->IsString()
        && info[1]->IsInt32())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Management::Deployment::PackageStatus arg1 = static_cast<::Windows::Management::Deployment::PackageStatus>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          wrapper->_instance->SetPackageStatus(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageManager^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Management::Deployment::PackageManagerDebugSettings^ result = wrapper->_instance->DebugSettings;
        info.GetReturnValue().Set(WrapPackageManagerDebugSettings(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Management::Deployment::PackageManager^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPackageManager(::Windows::Management::Deployment::PackageManager^ wintRtInstance);
      friend ::Windows::Management::Deployment::PackageManager^ UnwrapPackageManager(Local<Value> value);
  };

  Persistent<FunctionTemplate> PackageManager::s_constructorTemplate;

  v8::Local<v8::Value> WrapPackageManager(::Windows::Management::Deployment::PackageManager^ 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>(PackageManager::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Management::Deployment::PackageManager^ UnwrapPackageManager(Local<Value> value) {
     return PackageManager::Unwrap<PackageManager>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPackageManager(Local<Object> exports) {
    PackageManager::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::Management::Deployment::InitDeploymentProgressStateEnum(target);
      NodeRT::Windows::Management::Deployment::InitDeploymentOptionsEnum(target);
      NodeRT::Windows::Management::Deployment::InitRemovalOptionsEnum(target);
      NodeRT::Windows::Management::Deployment::InitPackageTypesEnum(target);
      NodeRT::Windows::Management::Deployment::InitPackageInstallStateEnum(target);
      NodeRT::Windows::Management::Deployment::InitPackageStateEnum(target);
      NodeRT::Windows::Management::Deployment::InitPackageStatusEnum(target);
      NodeRT::Windows::Management::Deployment::InitDeploymentResult(target);
      NodeRT::Windows::Management::Deployment::InitPackageUserInformation(target);
      NodeRT::Windows::Management::Deployment::InitPackageVolume(target);
      NodeRT::Windows::Management::Deployment::InitPackageManagerDebugSettings(target);
      NodeRT::Windows::Management::Deployment::InitPackageManager(target);


  NodeRT::Utils::RegisterNameSpace("Windows.Management.Deployment", target);
}



NODE_MODULE(binding, init)