// 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> WrapAddPackageOptions(::Windows::Management::Deployment::AddPackageOptions^ wintRtInstance);
  ::Windows::Management::Deployment::AddPackageOptions^ UnwrapAddPackageOptions(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppInstallerManager(::Windows::Management::Deployment::AppInstallerManager^ wintRtInstance);
  ::Windows::Management::Deployment::AppInstallerManager^ UnwrapAppInstallerManager(Local<Value> value);
  
  v8::Local<v8::Value> WrapAutoUpdateSettingsOptions(::Windows::Management::Deployment::AutoUpdateSettingsOptions^ wintRtInstance);
  ::Windows::Management::Deployment::AutoUpdateSettingsOptions^ UnwrapAutoUpdateSettingsOptions(Local<Value> value);
  
  v8::Local<v8::Value> WrapCreateSharedPackageContainerOptions(::Windows::Management::Deployment::CreateSharedPackageContainerOptions^ wintRtInstance);
  ::Windows::Management::Deployment::CreateSharedPackageContainerOptions^ UnwrapCreateSharedPackageContainerOptions(Local<Value> value);
  
  v8::Local<v8::Value> WrapCreateSharedPackageContainerResult(::Windows::Management::Deployment::CreateSharedPackageContainerResult^ wintRtInstance);
  ::Windows::Management::Deployment::CreateSharedPackageContainerResult^ UnwrapCreateSharedPackageContainerResult(Local<Value> value);
  
  v8::Local<v8::Value> WrapDeleteSharedPackageContainerOptions(::Windows::Management::Deployment::DeleteSharedPackageContainerOptions^ wintRtInstance);
  ::Windows::Management::Deployment::DeleteSharedPackageContainerOptions^ UnwrapDeleteSharedPackageContainerOptions(Local<Value> value);
  
  v8::Local<v8::Value> WrapDeleteSharedPackageContainerResult(::Windows::Management::Deployment::DeleteSharedPackageContainerResult^ wintRtInstance);
  ::Windows::Management::Deployment::DeleteSharedPackageContainerResult^ UnwrapDeleteSharedPackageContainerResult(Local<Value> value);
  
  v8::Local<v8::Value> WrapDeploymentResult(::Windows::Management::Deployment::DeploymentResult^ wintRtInstance);
  ::Windows::Management::Deployment::DeploymentResult^ UnwrapDeploymentResult(Local<Value> value);
  
  v8::Local<v8::Value> WrapFindSharedPackageContainerOptions(::Windows::Management::Deployment::FindSharedPackageContainerOptions^ wintRtInstance);
  ::Windows::Management::Deployment::FindSharedPackageContainerOptions^ UnwrapFindSharedPackageContainerOptions(Local<Value> value);
  
  v8::Local<v8::Value> WrapPackageAllUserProvisioningOptions(::Windows::Management::Deployment::PackageAllUserProvisioningOptions^ wintRtInstance);
  ::Windows::Management::Deployment::PackageAllUserProvisioningOptions^ UnwrapPackageAllUserProvisioningOptions(Local<Value> value);
  
  v8::Local<v8::Value> WrapPackageManager(::Windows::Management::Deployment::PackageManager^ wintRtInstance);
  ::Windows::Management::Deployment::PackageManager^ UnwrapPackageManager(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> 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> WrapRegisterPackageOptions(::Windows::Management::Deployment::RegisterPackageOptions^ wintRtInstance);
  ::Windows::Management::Deployment::RegisterPackageOptions^ UnwrapRegisterPackageOptions(Local<Value> value);
  
  v8::Local<v8::Value> WrapSharedPackageContainer(::Windows::Management::Deployment::SharedPackageContainer^ wintRtInstance);
  ::Windows::Management::Deployment::SharedPackageContainer^ UnwrapSharedPackageContainer(Local<Value> value);
  
  v8::Local<v8::Value> WrapSharedPackageContainerManager(::Windows::Management::Deployment::SharedPackageContainerManager^ wintRtInstance);
  ::Windows::Management::Deployment::SharedPackageContainerManager^ UnwrapSharedPackageContainerManager(Local<Value> value);
  
  v8::Local<v8::Value> WrapSharedPackageContainerMember(::Windows::Management::Deployment::SharedPackageContainerMember^ wintRtInstance);
  ::Windows::Management::Deployment::SharedPackageContainerMember^ UnwrapSharedPackageContainerMember(Local<Value> value);
  
  v8::Local<v8::Value> WrapStagePackageOptions(::Windows::Management::Deployment::StagePackageOptions^ wintRtInstance);
  ::Windows::Management::Deployment::StagePackageOptions^ UnwrapStagePackageOptions(Local<Value> value);
  
  v8::Local<v8::Value> WrapUpdateSharedPackageContainerOptions(::Windows::Management::Deployment::UpdateSharedPackageContainerOptions^ wintRtInstance);
  ::Windows::Management::Deployment::UpdateSharedPackageContainerOptions^ UnwrapUpdateSharedPackageContainerOptions(Local<Value> value);
  
  v8::Local<v8::Value> WrapUpdateSharedPackageContainerResult(::Windows::Management::Deployment::UpdateSharedPackageContainerResult^ wintRtInstance);
  ::Windows::Management::Deployment::UpdateSharedPackageContainerResult^ UnwrapUpdateSharedPackageContainerResult(Local<Value> value);
  



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

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

    Nan::Set(exports, Nan::New<String>("AddPackageByAppInstallerOptions").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::AddPackageByAppInstallerOptions::None)));
    Nan::Set(enumObject, Nan::New<String>("installAllResources").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::AddPackageByAppInstallerOptions::InstallAllResources)));
    Nan::Set(enumObject, Nan::New<String>("forceTargetAppShutdown").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::AddPackageByAppInstallerOptions::ForceTargetAppShutdown)));
    Nan::Set(enumObject, Nan::New<String>("requiredContentGroupOnly").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::AddPackageByAppInstallerOptions::RequiredContentGroupOnly)));
    Nan::Set(enumObject, Nan::New<String>("limitToExistingPackages").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::AddPackageByAppInstallerOptions::LimitToExistingPackages)));
  }

  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)));
    Nan::Set(enumObject, Nan::New<String>("forceUpdateFromAnyVersion").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::DeploymentOptions::ForceUpdateFromAnyVersion)));
    Nan::Set(enumObject, Nan::New<String>("retainFilesOnFailure").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::DeploymentOptions::RetainFilesOnFailure)));
    Nan::Set(enumObject, Nan::New<String>("stageInPlace").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::DeploymentOptions::StageInPlace)));
  }

  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 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 void InitPackageStubPreferenceEnum(const Local<Object> exports) {
    HandleScope scope;

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

    Nan::Set(exports, Nan::New<String>("PackageStubPreference").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("full").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::PackageStubPreference::Full)));
    Nan::Set(enumObject, Nan::New<String>("stub").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::PackageStubPreference::Stub)));
  }

  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)));
    Nan::Set(enumObject, Nan::New<String>("all").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::PackageTypes::All)));
  }

  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>("preserveRoamableApplicationData").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::RemovalOptions::PreserveRoamableApplicationData)));
    Nan::Set(enumObject, Nan::New<String>("preserveApplicationData").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::RemovalOptions::PreserveApplicationData)));
    Nan::Set(enumObject, Nan::New<String>("removeForAllUsers").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::RemovalOptions::RemoveForAllUsers)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("SharedPackageContainerCreationCollisionOptions").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("failIfExists").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::SharedPackageContainerCreationCollisionOptions::FailIfExists)));
    Nan::Set(enumObject, Nan::New<String>("mergeWithExisting").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::SharedPackageContainerCreationCollisionOptions::MergeWithExisting)));
    Nan::Set(enumObject, Nan::New<String>("replaceExisting").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::SharedPackageContainerCreationCollisionOptions::ReplaceExisting)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("SharedPackageContainerOperationStatus").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("success").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::SharedPackageContainerOperationStatus::Success)));
    Nan::Set(enumObject, Nan::New<String>("blockedByPolicy").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::SharedPackageContainerOperationStatus::BlockedByPolicy)));
    Nan::Set(enumObject, Nan::New<String>("alreadyExists").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::SharedPackageContainerOperationStatus::AlreadyExists)));
    Nan::Set(enumObject, Nan::New<String>("packageFamilyExistsInAnotherContainer").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::SharedPackageContainerOperationStatus::PackageFamilyExistsInAnotherContainer)));
    Nan::Set(enumObject, Nan::New<String>("notFound").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::SharedPackageContainerOperationStatus::NotFound)));
    Nan::Set(enumObject, Nan::New<String>("unknownFailure").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::SharedPackageContainerOperationStatus::UnknownFailure)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("StubPackageOption").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("default").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::StubPackageOption::Default)));
    Nan::Set(enumObject, Nan::New<String>("installFull").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::StubPackageOption::InstallFull)));
    Nan::Set(enumObject, Nan::New<String>("installStub").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::StubPackageOption::InstallStub)));
    Nan::Set(enumObject, Nan::New<String>("usePreference").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Management::Deployment::StubPackageOption::UsePreference)));
  }

  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);
  }
  static bool IsSharedPackageContainerContractJsObject(Local<Value> value) {
    if (!value->IsObject()) {
      return false;
    }

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

    return true;
  }

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

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

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

    return returnValue;
  }

  Local<Value> SharedPackageContainerContractToJsObject(::Windows::Management::Deployment::SharedPackageContainerContract value) {
    EscapableHandleScope scope;

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


    return scope.Escape(obj);
  }

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

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

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

  ::Windows::ApplicationModel::PackageVersion PackageVersionFromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::ApplicationModel::PackageVersion 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>("major").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.Major = static_cast<unsigned short>(Nan::To<int32_t>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0));
    }
    
    symbol = Nan::New<String>("minor").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.Minor = static_cast<unsigned short>(Nan::To<int32_t>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0));
    }
    
    symbol = Nan::New<String>("build").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.Build = static_cast<unsigned short>(Nan::To<int32_t>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0));
    }
    
    symbol = Nan::New<String>("revision").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.Revision = static_cast<unsigned short>(Nan::To<int32_t>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0));
    }
    
    return returnValue;
  }

  Local<Value> PackageVersionToJsObject(::Windows::ApplicationModel::PackageVersion value) {
    EscapableHandleScope scope;

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

    Nan::Set(obj, Nan::New<String>("major").ToLocalChecked(), Nan::New<Integer>(value.Major));
    Nan::Set(obj, Nan::New<String>("minor").ToLocalChecked(), Nan::New<Integer>(value.Minor));
    Nan::Set(obj, Nan::New<String>("build").ToLocalChecked(), Nan::New<Integer>(value.Build));
    Nan::Set(obj, Nan::New<String>("revision").ToLocalChecked(), Nan::New<Integer>(value.Revision));

    return scope.Escape(obj);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("targetVolume").ToLocalChecked(), TargetVolumeGetter, TargetVolumeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("stubPackageOption").ToLocalChecked(), StubPackageOptionGetter, StubPackageOptionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("stageInPlace").ToLocalChecked(), StageInPlaceGetter, StageInPlaceSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("retainFilesOnFailure").ToLocalChecked(), RetainFilesOnFailureGetter, RetainFilesOnFailureSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("requiredContentGroupOnly").ToLocalChecked(), RequiredContentGroupOnlyGetter, RequiredContentGroupOnlySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("installAllResources").ToLocalChecked(), InstallAllResourcesGetter, InstallAllResourcesSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("forceUpdateFromAnyVersion").ToLocalChecked(), ForceUpdateFromAnyVersionGetter, ForceUpdateFromAnyVersionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("forceTargetAppShutdown").ToLocalChecked(), ForceTargetAppShutdownGetter, ForceTargetAppShutdownSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("forceAppShutdown").ToLocalChecked(), ForceAppShutdownGetter, ForceAppShutdownSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("externalLocationUri").ToLocalChecked(), ExternalLocationUriGetter, ExternalLocationUriSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("developerMode").ToLocalChecked(), DeveloperModeGetter, DeveloperModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("deferRegistrationWhenPackagesAreInUse").ToLocalChecked(), DeferRegistrationWhenPackagesAreInUseGetter, DeferRegistrationWhenPackagesAreInUseSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("allowUnsigned").ToLocalChecked(), AllowUnsignedGetter, AllowUnsignedSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dependencyPackageUris").ToLocalChecked(), DependencyPackageUrisGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("optionalPackageFamilyNames").ToLocalChecked(), OptionalPackageFamilyNamesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("optionalPackageUris").ToLocalChecked(), OptionalPackageUrisGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("relatedPackageUris").ToLocalChecked(), RelatedPackageUrisGetter);

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



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

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

    private:

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


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

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

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





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

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

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

      try  {
        ::Windows::Management::Deployment::PackageVolume^ result = wrapper->_instance->TargetVolume;
        info.GetReturnValue().Set(WrapPackageVolume(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TargetVolumeSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

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

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

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

      try {

        ::Windows::Management::Deployment::PackageVolume^ winRtValue = dynamic_cast<::Windows::Management::Deployment::PackageVolume^>(NodeRT::Utils::GetObjectInstance(value));

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

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

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

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

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

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

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

      try {

        ::Windows::Management::Deployment::StubPackageOption winRtValue = static_cast<::Windows::Management::Deployment::StubPackageOption>(Nan::To<int32_t>(value).FromMaybe(0));

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

      friend v8::Local<v8::Value> WrapAddPackageOptions(::Windows::Management::Deployment::AddPackageOptions^ wintRtInstance);
      friend ::Windows::Management::Deployment::AddPackageOptions^ UnwrapAddPackageOptions(Local<Value> value);
  };

  Persistent<FunctionTemplate> AddPackageOptions::s_constructorTemplate;

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

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

  void InitAddPackageOptions(Local<Object> exports) {
    AddPackageOptions::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "setAutoUpdateSettings", SetAutoUpdateSettings);
            Nan::SetPrototypeMethod(localRef, "clearAutoUpdateSettings", ClearAutoUpdateSettings);
            Nan::SetPrototypeMethod(localRef, "pauseAutoUpdatesUntil", PauseAutoUpdatesUntil);
          




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

        Nan::SetMethod(constructor, "getDefault", GetDefault);
        Nan::SetMethod(constructor, "getForSystem", GetForSystem);


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

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

    private:

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


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

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

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


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

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

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

      if (info.Length() == 2
        && info[0]->IsString()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::AutoUpdateSettingsOptions^>(info[1]))
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Management::Deployment::AutoUpdateSettingsOptions^ arg1 = UnwrapAutoUpdateSettingsOptions(info[1]);
          
          wrapper->_instance->SetAutoUpdateSettings(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 ClearAutoUpdateSettings(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

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

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

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Management::Deployment::AppInstallerManager^ result;
          result = ::Windows::Management::Deployment::AppInstallerManager::GetDefault();
          info.GetReturnValue().Set(WrapAppInstallerManager(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 GetForSystem(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Management::Deployment::AppInstallerManager^ result;
          result = ::Windows::Management::Deployment::AppInstallerManager::GetForSystem();
          info.GetReturnValue().Set(WrapAppInstallerManager(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



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

      friend v8::Local<v8::Value> WrapAppInstallerManager(::Windows::Management::Deployment::AppInstallerManager^ wintRtInstance);
      friend ::Windows::Management::Deployment::AppInstallerManager^ UnwrapAppInstallerManager(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppInstallerManager::s_constructorTemplate;

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

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

  void InitAppInstallerManager(Local<Object> exports) {
    AppInstallerManager::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("version").ToLocalChecked(), VersionGetter, VersionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("updateBlocksActivation").ToLocalChecked(), UpdateBlocksActivationGetter, UpdateBlocksActivationSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("showPrompt").ToLocalChecked(), ShowPromptGetter, ShowPromptSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("onLaunch").ToLocalChecked(), OnLaunchGetter, OnLaunchSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isAutoRepairEnabled").ToLocalChecked(), IsAutoRepairEnabledGetter, IsAutoRepairEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("hoursBetweenUpdateChecks").ToLocalChecked(), HoursBetweenUpdateChecksGetter, HoursBetweenUpdateChecksSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("forceUpdateFromAnyVersion").ToLocalChecked(), ForceUpdateFromAnyVersionGetter, ForceUpdateFromAnyVersionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("automaticBackgroundTask").ToLocalChecked(), AutomaticBackgroundTaskGetter, AutomaticBackgroundTaskSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("appInstallerUri").ToLocalChecked(), AppInstallerUriGetter, AppInstallerUriSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dependencyPackageUris").ToLocalChecked(), DependencyPackageUrisGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("optionalPackageUris").ToLocalChecked(), OptionalPackageUrisGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("repairUris").ToLocalChecked(), RepairUrisGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("updateUris").ToLocalChecked(), UpdateUrisGetter);

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

        Nan::SetMethod(constructor, "createFromAppInstallerInfo", CreateFromAppInstallerInfo);


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

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

    private:

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


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

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

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





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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::ApplicationModel::AppInstallerInfo^>(info[0]))
      {
        try
        {
          ::Windows::ApplicationModel::AppInstallerInfo^ arg0 = dynamic_cast<::Windows::ApplicationModel::AppInstallerInfo^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::Management::Deployment::AutoUpdateSettingsOptions^ result;
          result = ::Windows::Management::Deployment::AutoUpdateSettingsOptions::CreateFromAppInstallerInfo(arg0);
          info.GetReturnValue().Set(WrapAutoUpdateSettingsOptions(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 VersionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

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

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

      try {

        ::Windows::ApplicationModel::PackageVersion winRtValue = PackageVersionFromJsObject(value);

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

      friend v8::Local<v8::Value> WrapAutoUpdateSettingsOptions(::Windows::Management::Deployment::AutoUpdateSettingsOptions^ wintRtInstance);
      friend ::Windows::Management::Deployment::AutoUpdateSettingsOptions^ UnwrapAutoUpdateSettingsOptions(Local<Value> value);
  };

  Persistent<FunctionTemplate> AutoUpdateSettingsOptions::s_constructorTemplate;

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

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

  void InitAutoUpdateSettingsOptions(Local<Object> exports) {
    AutoUpdateSettingsOptions::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("forceAppShutdown").ToLocalChecked(), ForceAppShutdownGetter, ForceAppShutdownSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("createCollisionOption").ToLocalChecked(), CreateCollisionOptionGetter, CreateCollisionOptionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("members").ToLocalChecked(), MembersGetter);

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



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

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

    private:

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


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

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

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





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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

        ::Windows::Management::Deployment::SharedPackageContainerCreationCollisionOptions winRtValue = static_cast<::Windows::Management::Deployment::SharedPackageContainerCreationCollisionOptions>(Nan::To<int32_t>(value).FromMaybe(0));

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

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

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::Management::Deployment::SharedPackageContainerMember^>^ result = wrapper->_instance->Members;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Management::Deployment::SharedPackageContainerMember^>::CreateVectorWrapper(result, 
            [](::Windows::Management::Deployment::SharedPackageContainerMember^ val) -> Local<Value> {
              return WrapSharedPackageContainerMember(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::SharedPackageContainerMember^>(value);
            },
            [](Local<Value> value) -> ::Windows::Management::Deployment::SharedPackageContainerMember^ {
              return UnwrapSharedPackageContainerMember(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


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

      friend v8::Local<v8::Value> WrapCreateSharedPackageContainerOptions(::Windows::Management::Deployment::CreateSharedPackageContainerOptions^ wintRtInstance);
      friend ::Windows::Management::Deployment::CreateSharedPackageContainerOptions^ UnwrapCreateSharedPackageContainerOptions(Local<Value> value);
  };

  Persistent<FunctionTemplate> CreateSharedPackageContainerOptions::s_constructorTemplate;

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

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

  void InitCreateSharedPackageContainerOptions(Local<Object> exports) {
    CreateSharedPackageContainerOptions::Init(exports);
  }

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





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

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



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

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

    private:

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


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

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

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





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

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

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

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

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

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

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

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

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

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


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

      friend v8::Local<v8::Value> WrapCreateSharedPackageContainerResult(::Windows::Management::Deployment::CreateSharedPackageContainerResult^ wintRtInstance);
      friend ::Windows::Management::Deployment::CreateSharedPackageContainerResult^ UnwrapCreateSharedPackageContainerResult(Local<Value> value);
  };

  Persistent<FunctionTemplate> CreateSharedPackageContainerResult::s_constructorTemplate;

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

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

  void InitCreateSharedPackageContainerResult(Local<Object> exports) {
    CreateSharedPackageContainerResult::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("forceAppShutdown").ToLocalChecked(), ForceAppShutdownGetter, ForceAppShutdownSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("allUsers").ToLocalChecked(), AllUsersGetter, AllUsersSetter);

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



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

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

    private:

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


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

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

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





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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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


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

      friend v8::Local<v8::Value> WrapDeleteSharedPackageContainerOptions(::Windows::Management::Deployment::DeleteSharedPackageContainerOptions^ wintRtInstance);
      friend ::Windows::Management::Deployment::DeleteSharedPackageContainerOptions^ UnwrapDeleteSharedPackageContainerOptions(Local<Value> value);
  };

  Persistent<FunctionTemplate> DeleteSharedPackageContainerOptions::s_constructorTemplate;

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

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

  void InitDeleteSharedPackageContainerOptions(Local<Object> exports) {
    DeleteSharedPackageContainerOptions::Init(exports);
  }

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





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

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



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

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

    private:

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


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

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

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





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

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

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

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

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

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

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


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

      friend v8::Local<v8::Value> WrapDeleteSharedPackageContainerResult(::Windows::Management::Deployment::DeleteSharedPackageContainerResult^ wintRtInstance);
      friend ::Windows::Management::Deployment::DeleteSharedPackageContainerResult^ UnwrapDeleteSharedPackageContainerResult(Local<Value> value);
  };

  Persistent<FunctionTemplate> DeleteSharedPackageContainerResult::s_constructorTemplate;

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

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

  void InitDeleteSharedPackageContainerResult(Local<Object> exports) {
    DeleteSharedPackageContainerResult::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("packageFamilyName").ToLocalChecked(), PackageFamilyNameGetter, PackageFamilyNameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("name").ToLocalChecked(), NameGetter, NameSetter);

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



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

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

    private:

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


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

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

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





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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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


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

      friend v8::Local<v8::Value> WrapFindSharedPackageContainerOptions(::Windows::Management::Deployment::FindSharedPackageContainerOptions^ wintRtInstance);
      friend ::Windows::Management::Deployment::FindSharedPackageContainerOptions^ UnwrapFindSharedPackageContainerOptions(Local<Value> value);
  };

  Persistent<FunctionTemplate> FindSharedPackageContainerOptions::s_constructorTemplate;

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

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

  void InitFindSharedPackageContainerOptions(Local<Object> exports) {
    FindSharedPackageContainerOptions::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("optionalPackageFamilyNames").ToLocalChecked(), OptionalPackageFamilyNamesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("projectionOrderPackageFamilyNames").ToLocalChecked(), ProjectionOrderPackageFamilyNamesGetter);

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



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

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

    private:

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


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

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

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





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

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

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

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

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

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

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


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

      friend v8::Local<v8::Value> WrapPackageAllUserProvisioningOptions(::Windows::Management::Deployment::PackageAllUserProvisioningOptions^ wintRtInstance);
      friend ::Windows::Management::Deployment::PackageAllUserProvisioningOptions^ UnwrapPackageAllUserProvisioningOptions(Local<Value> value);
  };

  Persistent<FunctionTemplate> PackageAllUserProvisioningOptions::s_constructorTemplate;

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

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

  void InitPackageAllUserProvisioningOptions(Local<Object> exports) {
    PackageAllUserProvisioningOptions::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, "findProvisionedPackages", FindProvisionedPackages);
            Nan::SetPrototypeMethod(localRef, "setPackageStubPreference", SetPackageStubPreference);
            Nan::SetPrototypeMethod(localRef, "getPackageStubPreference", GetPackageStubPreference);
            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, "stagePackageAsync", StagePackageAsync);
            Nan::SetPrototypeMethod(localRef, "requestAddPackageAsync", RequestAddPackageAsync);
            Nan::SetPrototypeMethod(localRef, "deprovisionPackageForAllUsersAsync", DeprovisionPackageForAllUsersAsync);
            Nan::SetPrototypeMethod(localRef, "addPackageByUriAsync", AddPackageByUriAsync);
            Nan::SetPrototypeMethod(localRef, "stagePackageByUriAsync", StagePackageByUriAsync);
            Nan::SetPrototypeMethod(localRef, "registerPackageByUriAsync", RegisterPackageByUriAsync);
            Nan::SetPrototypeMethod(localRef, "registerPackagesByFullNameAsync", RegisterPackagesByFullNameAsync);
            Nan::SetPrototypeMethod(localRef, "provisionPackageForAllUsersAsync", ProvisionPackageForAllUsersAsync);
            Nan::SetPrototypeMethod(localRef, "addPackageAsync", AddPackageAsync);
            Nan::SetPrototypeMethod(localRef, "updatePackageAsync", UpdatePackageAsync);
            Nan::SetPrototypeMethod(localRef, "removePackageAsync", RemovePackageAsync);
            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::SetPrototypeMethod(localRef, "addPackageByAppInstallerFileAsync", AddPackageByAppInstallerFileAsync);
            Nan::SetPrototypeMethod(localRef, "requestAddPackageByAppInstallerFileAsync", RequestAddPackageByAppInstallerFileAsync);
          


          
            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 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() == 8
        && 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())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^>(info[6]) || info[6]->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]);
          ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^ arg6 = 
            [] (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[6]);
          
          op = wrapper->_instance->StagePackageAsync(arg0,arg1,arg2,arg3,arg4,arg5,arg6);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else 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 RequestAddPackageAsync(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() == 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->RequestAddPackageAsync(arg0,arg1,arg2,arg3,arg4,arg5);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 8
        && 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())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^>(info[6]) || info[6]->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]);
          ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^ arg6 = 
            [] (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[6]);
          
          op = wrapper->_instance->RequestAddPackageAsync(arg0,arg1,arg2,arg3,arg4,arg5,arg6);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"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 DeprovisionPackageForAllUsersAsync(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->DeprovisionPackageForAllUsersAsync(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 AddPackageByUriAsync(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::Management::Deployment::AddPackageOptions^>(info[1]))
      {
        try
        {
          ::Windows::Foundation::Uri^ arg0 = dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Management::Deployment::AddPackageOptions^ arg1 = UnwrapAddPackageOptions(info[1]);
          
          op = wrapper->_instance->AddPackageByUriAsync(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 StagePackageByUriAsync(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::Management::Deployment::StagePackageOptions^>(info[1]))
      {
        try
        {
          ::Windows::Foundation::Uri^ arg0 = dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Management::Deployment::StagePackageOptions^ arg1 = UnwrapStagePackageOptions(info[1]);
          
          op = wrapper->_instance->StagePackageByUriAsync(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 RegisterPackageByUriAsync(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::Management::Deployment::RegisterPackageOptions^>(info[1]))
      {
        try
        {
          ::Windows::Foundation::Uri^ arg0 = dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Management::Deployment::RegisterPackageOptions^ arg1 = UnwrapRegisterPackageOptions(info[1]);
          
          op = wrapper->_instance->RegisterPackageByUriAsync(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 RegisterPackagesByFullNameAsync(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::Collections::IIterable<::Platform::String^>^>(info[0]) || info[0]->IsArray())
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::RegisterPackageOptions^>(info[1]))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<::Platform::String^>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Platform::String^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Platform::String^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return (!NodeRT::Utils::IsWinRtWrapper(value));
                 },
                 [](Local<Value> value) -> ::Platform::String^ {
                   return ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Platform::String^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Management::Deployment::RegisterPackageOptions^ arg1 = UnwrapRegisterPackageOptions(info[1]);
          
          op = wrapper->_instance->RegisterPackagesByFullNameAsync(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 ProvisionPackageForAllUsersAsync(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()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageAllUserProvisioningOptions^>(info[1]))
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Management::Deployment::PackageAllUserProvisioningOptions^ arg1 = UnwrapPackageAllUserProvisioningOptions(info[1]);
          
          op = wrapper->_instance->ProvisionPackageForAllUsersAsync(arg0,arg1);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          op = wrapper->_instance->ProvisionPackageForAllUsersAsync(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 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 if (info.Length() == 8
        && 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())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^>(info[6]) || info[6]->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]);
          ::Windows::Foundation::Collections::IIterable<::Windows::Foundation::Uri^>^ arg6 = 
            [] (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[6]);
          
          op = wrapper->_instance->AddPackageAsync(arg0,arg1,arg2,arg3,arg4,arg5,arg6);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"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 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 AddPackageByAppInstallerFileAsync(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])
        && info[1]->IsInt32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(info[2]))
      {
        try
        {
          ::Windows::Foundation::Uri^ arg0 = dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Management::Deployment::AddPackageByAppInstallerOptions arg1 = static_cast<::Windows::Management::Deployment::AddPackageByAppInstallerOptions>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          ::Windows::Management::Deployment::PackageVolume^ arg2 = UnwrapPackageVolume(info[2]);
          
          op = wrapper->_instance->AddPackageByAppInstallerFileAsync(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 RequestAddPackageByAppInstallerFileAsync(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])
        && info[1]->IsInt32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::PackageVolume^>(info[2]))
      {
        try
        {
          ::Windows::Foundation::Uri^ arg0 = dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Management::Deployment::AddPackageByAppInstallerOptions arg1 = static_cast<::Windows::Management::Deployment::AddPackageByAppInstallerOptions>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          ::Windows::Management::Deployment::PackageVolume^ arg2 = UnwrapPackageVolume(info[2]);
          
          op = wrapper->_instance->RequestAddPackageByAppInstallerFileAsync(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 FindProvisionedPackages(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::IVector<::Windows::ApplicationModel::Package^>^ result;
          result = wrapper->_instance->FindProvisionedPackages();
          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 SetPackageStubPreference(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::PackageStubPreference arg1 = static_cast<::Windows::Management::Deployment::PackageStubPreference>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          wrapper->_instance->SetPackageStubPreference(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 GetPackageStubPreference(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::PackageStubPreference result;
          result = wrapper->_instance->GetPackageStubPreference(arg0);
          info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void 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);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("stageInPlace").ToLocalChecked(), StageInPlaceGetter, StageInPlaceSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("installAllResources").ToLocalChecked(), InstallAllResourcesGetter, InstallAllResourcesSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("forceUpdateFromAnyVersion").ToLocalChecked(), ForceUpdateFromAnyVersionGetter, ForceUpdateFromAnyVersionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("forceTargetAppShutdown").ToLocalChecked(), ForceTargetAppShutdownGetter, ForceTargetAppShutdownSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("forceAppShutdown").ToLocalChecked(), ForceAppShutdownGetter, ForceAppShutdownSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("externalLocationUri").ToLocalChecked(), ExternalLocationUriGetter, ExternalLocationUriSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("developerMode").ToLocalChecked(), DeveloperModeGetter, DeveloperModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("deferRegistrationWhenPackagesAreInUse").ToLocalChecked(), DeferRegistrationWhenPackagesAreInUseGetter, DeferRegistrationWhenPackagesAreInUseSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("appDataVolume").ToLocalChecked(), AppDataVolumeGetter, AppDataVolumeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("allowUnsigned").ToLocalChecked(), AllowUnsignedGetter, AllowUnsignedSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dependencyPackageUris").ToLocalChecked(), DependencyPackageUrisGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("optionalPackageFamilyNames").ToLocalChecked(), OptionalPackageFamilyNamesGetter);

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



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

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

    private:

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


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

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

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





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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

      try  {
        ::Windows::Management::Deployment::PackageVolume^ result = wrapper->_instance->AppDataVolume;
        info.GetReturnValue().Set(WrapPackageVolume(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AppDataVolumeSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

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

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

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

      try {

        ::Windows::Management::Deployment::PackageVolume^ winRtValue = dynamic_cast<::Windows::Management::Deployment::PackageVolume^>(NodeRT::Utils::GetObjectInstance(value));

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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


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

      friend v8::Local<v8::Value> WrapRegisterPackageOptions(::Windows::Management::Deployment::RegisterPackageOptions^ wintRtInstance);
      friend ::Windows::Management::Deployment::RegisterPackageOptions^ UnwrapRegisterPackageOptions(Local<Value> value);
  };

  Persistent<FunctionTemplate> RegisterPackageOptions::s_constructorTemplate;

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

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

  void InitRegisterPackageOptions(Local<Object> exports) {
    RegisterPackageOptions::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getMembers", GetMembers);
            Nan::SetPrototypeMethod(localRef, "removePackageFamily", RemovePackageFamily);
            Nan::SetPrototypeMethod(localRef, "resetData", ResetData);
          



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

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



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

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

    private:

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


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

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

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


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

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVector<::Windows::Management::Deployment::SharedPackageContainerMember^>^ result;
          result = wrapper->_instance->GetMembers();
          info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Management::Deployment::SharedPackageContainerMember^>::CreateVectorWrapper(result, 
            [](::Windows::Management::Deployment::SharedPackageContainerMember^ val) -> Local<Value> {
              return WrapSharedPackageContainerMember(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::SharedPackageContainerMember^>(value);
            },
            [](Local<Value> value) -> ::Windows::Management::Deployment::SharedPackageContainerMember^ {
              return UnwrapSharedPackageContainerMember(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 RemovePackageFamily(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 2
        && info[0]->IsString()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::UpdateSharedPackageContainerOptions^>(info[1]))
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Management::Deployment::UpdateSharedPackageContainerOptions^ arg1 = UnwrapUpdateSharedPackageContainerOptions(info[1]);
          
          ::Windows::Management::Deployment::UpdateSharedPackageContainerResult^ result;
          result = wrapper->_instance->RemovePackageFamily(arg0, arg1);
          info.GetReturnValue().Set(WrapUpdateSharedPackageContainerResult(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 ResetData(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Management::Deployment::UpdateSharedPackageContainerResult^ result;
          result = wrapper->_instance->ResetData();
          info.GetReturnValue().Set(WrapUpdateSharedPackageContainerResult(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 IdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

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

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

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

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

      SharedPackageContainer *wrapper = SharedPackageContainer::Unwrap<SharedPackageContainer>(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;
      }
    }
      


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

      friend v8::Local<v8::Value> WrapSharedPackageContainer(::Windows::Management::Deployment::SharedPackageContainer^ wintRtInstance);
      friend ::Windows::Management::Deployment::SharedPackageContainer^ UnwrapSharedPackageContainer(Local<Value> value);
  };

  Persistent<FunctionTemplate> SharedPackageContainer::s_constructorTemplate;

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

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

  void InitSharedPackageContainer(Local<Object> exports) {
    SharedPackageContainer::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "createContainer", CreateContainer);
            Nan::SetPrototypeMethod(localRef, "deleteContainer", DeleteContainer);
            Nan::SetPrototypeMethod(localRef, "getContainer", GetContainer);
            Nan::SetPrototypeMethod(localRef, "findContainers", FindContainers);
          




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

        Nan::SetMethod(constructor, "getDefault", GetDefault);
        Nan::SetMethod(constructor, "getForUser", GetForUser);
        Nan::SetMethod(constructor, "getForProvisioning", GetForProvisioning);


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

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

    private:

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


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

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

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


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

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

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

      if (info.Length() == 2
        && info[0]->IsString()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::CreateSharedPackageContainerOptions^>(info[1]))
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Management::Deployment::CreateSharedPackageContainerOptions^ arg1 = UnwrapCreateSharedPackageContainerOptions(info[1]);
          
          ::Windows::Management::Deployment::CreateSharedPackageContainerResult^ result;
          result = wrapper->_instance->CreateContainer(arg0, arg1);
          info.GetReturnValue().Set(WrapCreateSharedPackageContainerResult(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 DeleteContainer(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 2
        && info[0]->IsString()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::DeleteSharedPackageContainerOptions^>(info[1]))
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Management::Deployment::DeleteSharedPackageContainerOptions^ arg1 = UnwrapDeleteSharedPackageContainerOptions(info[1]);
          
          ::Windows::Management::Deployment::DeleteSharedPackageContainerResult^ result;
          result = wrapper->_instance->DeleteContainer(arg0, arg1);
          info.GetReturnValue().Set(WrapDeleteSharedPackageContainerResult(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 GetContainer(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

      SharedPackageContainerManager *wrapper = SharedPackageContainerManager::Unwrap<SharedPackageContainerManager>(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::SharedPackageContainer^ result;
          result = wrapper->_instance->GetContainer(arg0);
          info.GetReturnValue().Set(WrapSharedPackageContainer(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 FindContainers(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVector<::Windows::Management::Deployment::SharedPackageContainer^>^ result;
          result = wrapper->_instance->FindContainers();
          info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Management::Deployment::SharedPackageContainer^>::CreateVectorWrapper(result, 
            [](::Windows::Management::Deployment::SharedPackageContainer^ val) -> Local<Value> {
              return WrapSharedPackageContainer(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::SharedPackageContainer^>(value);
            },
            [](Local<Value> value) -> ::Windows::Management::Deployment::SharedPackageContainer^ {
              return UnwrapSharedPackageContainer(value);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::FindSharedPackageContainerOptions^>(info[0]))
      {
        try
        {
          ::Windows::Management::Deployment::FindSharedPackageContainerOptions^ arg0 = UnwrapFindSharedPackageContainerOptions(info[0]);
          
          ::Windows::Foundation::Collections::IVector<::Windows::Management::Deployment::SharedPackageContainer^>^ result;
          result = wrapper->_instance->FindContainers(arg0);
          info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Management::Deployment::SharedPackageContainer^>::CreateVectorWrapper(result, 
            [](::Windows::Management::Deployment::SharedPackageContainer^ val) -> Local<Value> {
              return WrapSharedPackageContainer(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Management::Deployment::SharedPackageContainer^>(value);
            },
            [](Local<Value> value) -> ::Windows::Management::Deployment::SharedPackageContainer^ {
              return UnwrapSharedPackageContainer(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 GetDefault(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Management::Deployment::SharedPackageContainerManager^ result;
          result = ::Windows::Management::Deployment::SharedPackageContainerManager::GetDefault();
          info.GetReturnValue().Set(WrapSharedPackageContainerManager(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 GetForUser(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Management::Deployment::SharedPackageContainerManager^ result;
          result = ::Windows::Management::Deployment::SharedPackageContainerManager::GetForProvisioning();
          info.GetReturnValue().Set(WrapSharedPackageContainerManager(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



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

      friend v8::Local<v8::Value> WrapSharedPackageContainerManager(::Windows::Management::Deployment::SharedPackageContainerManager^ wintRtInstance);
      friend ::Windows::Management::Deployment::SharedPackageContainerManager^ UnwrapSharedPackageContainerManager(Local<Value> value);
  };

  Persistent<FunctionTemplate> SharedPackageContainerManager::s_constructorTemplate;

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

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

  void InitSharedPackageContainerManager(Local<Object> exports) {
    SharedPackageContainerManager::Init(exports);
  }

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





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

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



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

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

    private:

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


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

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

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

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





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

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

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

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


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

      friend v8::Local<v8::Value> WrapSharedPackageContainerMember(::Windows::Management::Deployment::SharedPackageContainerMember^ wintRtInstance);
      friend ::Windows::Management::Deployment::SharedPackageContainerMember^ UnwrapSharedPackageContainerMember(Local<Value> value);
  };

  Persistent<FunctionTemplate> SharedPackageContainerMember::s_constructorTemplate;

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

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

  void InitSharedPackageContainerMember(Local<Object> exports) {
    SharedPackageContainerMember::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("targetVolume").ToLocalChecked(), TargetVolumeGetter, TargetVolumeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("stubPackageOption").ToLocalChecked(), StubPackageOptionGetter, StubPackageOptionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("stageInPlace").ToLocalChecked(), StageInPlaceGetter, StageInPlaceSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("requiredContentGroupOnly").ToLocalChecked(), RequiredContentGroupOnlyGetter, RequiredContentGroupOnlySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("installAllResources").ToLocalChecked(), InstallAllResourcesGetter, InstallAllResourcesSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("forceUpdateFromAnyVersion").ToLocalChecked(), ForceUpdateFromAnyVersionGetter, ForceUpdateFromAnyVersionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("externalLocationUri").ToLocalChecked(), ExternalLocationUriGetter, ExternalLocationUriSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("developerMode").ToLocalChecked(), DeveloperModeGetter, DeveloperModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("allowUnsigned").ToLocalChecked(), AllowUnsignedGetter, AllowUnsignedSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dependencyPackageUris").ToLocalChecked(), DependencyPackageUrisGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("optionalPackageFamilyNames").ToLocalChecked(), OptionalPackageFamilyNamesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("optionalPackageUris").ToLocalChecked(), OptionalPackageUrisGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("relatedPackageUris").ToLocalChecked(), RelatedPackageUrisGetter);

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



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

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

    private:

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


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

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

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





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

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

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

      try  {
        ::Windows::Management::Deployment::PackageVolume^ result = wrapper->_instance->TargetVolume;
        info.GetReturnValue().Set(WrapPackageVolume(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TargetVolumeSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

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

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

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

      try {

        ::Windows::Management::Deployment::PackageVolume^ winRtValue = dynamic_cast<::Windows::Management::Deployment::PackageVolume^>(NodeRT::Utils::GetObjectInstance(value));

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

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

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

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

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

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

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

      try {

        ::Windows::Management::Deployment::StubPackageOption winRtValue = static_cast<::Windows::Management::Deployment::StubPackageOption>(Nan::To<int32_t>(value).FromMaybe(0));

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

      friend v8::Local<v8::Value> WrapStagePackageOptions(::Windows::Management::Deployment::StagePackageOptions^ wintRtInstance);
      friend ::Windows::Management::Deployment::StagePackageOptions^ UnwrapStagePackageOptions(Local<Value> value);
  };

  Persistent<FunctionTemplate> StagePackageOptions::s_constructorTemplate;

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

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

  void InitStagePackageOptions(Local<Object> exports) {
    StagePackageOptions::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("requirePackagesPresent").ToLocalChecked(), RequirePackagesPresentGetter, RequirePackagesPresentSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("forceAppShutdown").ToLocalChecked(), ForceAppShutdownGetter, ForceAppShutdownSetter);

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



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

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

    private:

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


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

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

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





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

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

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

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

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

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

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

      try {

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

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

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

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

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

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

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

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

      try {

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

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


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

      friend v8::Local<v8::Value> WrapUpdateSharedPackageContainerOptions(::Windows::Management::Deployment::UpdateSharedPackageContainerOptions^ wintRtInstance);
      friend ::Windows::Management::Deployment::UpdateSharedPackageContainerOptions^ UnwrapUpdateSharedPackageContainerOptions(Local<Value> value);
  };

  Persistent<FunctionTemplate> UpdateSharedPackageContainerOptions::s_constructorTemplate;

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

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

  void InitUpdateSharedPackageContainerOptions(Local<Object> exports) {
    UpdateSharedPackageContainerOptions::Init(exports);
  }

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





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

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



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

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

    private:

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


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

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

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





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

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

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

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

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

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

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


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

      friend v8::Local<v8::Value> WrapUpdateSharedPackageContainerResult(::Windows::Management::Deployment::UpdateSharedPackageContainerResult^ wintRtInstance);
      friend ::Windows::Management::Deployment::UpdateSharedPackageContainerResult^ UnwrapUpdateSharedPackageContainerResult(Local<Value> value);
  };

  Persistent<FunctionTemplate> UpdateSharedPackageContainerResult::s_constructorTemplate;

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

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

  void InitUpdateSharedPackageContainerResult(Local<Object> exports) {
    UpdateSharedPackageContainerResult::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::InitAddPackageByAppInstallerOptionsEnum(target);
      NodeRT::Windows::Management::Deployment::InitDeploymentOptionsEnum(target);
      NodeRT::Windows::Management::Deployment::InitDeploymentProgressStateEnum(target);
      NodeRT::Windows::Management::Deployment::InitPackageInstallStateEnum(target);
      NodeRT::Windows::Management::Deployment::InitPackageStateEnum(target);
      NodeRT::Windows::Management::Deployment::InitPackageStatusEnum(target);
      NodeRT::Windows::Management::Deployment::InitPackageStubPreferenceEnum(target);
      NodeRT::Windows::Management::Deployment::InitPackageTypesEnum(target);
      NodeRT::Windows::Management::Deployment::InitRemovalOptionsEnum(target);
      NodeRT::Windows::Management::Deployment::InitSharedPackageContainerCreationCollisionOptionsEnum(target);
      NodeRT::Windows::Management::Deployment::InitSharedPackageContainerOperationStatusEnum(target);
      NodeRT::Windows::Management::Deployment::InitStubPackageOptionEnum(target);
      NodeRT::Windows::Management::Deployment::InitAddPackageOptions(target);
      NodeRT::Windows::Management::Deployment::InitAppInstallerManager(target);
      NodeRT::Windows::Management::Deployment::InitAutoUpdateSettingsOptions(target);
      NodeRT::Windows::Management::Deployment::InitCreateSharedPackageContainerOptions(target);
      NodeRT::Windows::Management::Deployment::InitCreateSharedPackageContainerResult(target);
      NodeRT::Windows::Management::Deployment::InitDeleteSharedPackageContainerOptions(target);
      NodeRT::Windows::Management::Deployment::InitDeleteSharedPackageContainerResult(target);
      NodeRT::Windows::Management::Deployment::InitDeploymentResult(target);
      NodeRT::Windows::Management::Deployment::InitFindSharedPackageContainerOptions(target);
      NodeRT::Windows::Management::Deployment::InitPackageAllUserProvisioningOptions(target);
      NodeRT::Windows::Management::Deployment::InitPackageManager(target);
      NodeRT::Windows::Management::Deployment::InitPackageManagerDebugSettings(target);
      NodeRT::Windows::Management::Deployment::InitPackageUserInformation(target);
      NodeRT::Windows::Management::Deployment::InitPackageVolume(target);
      NodeRT::Windows::Management::Deployment::InitRegisterPackageOptions(target);
      NodeRT::Windows::Management::Deployment::InitSharedPackageContainer(target);
      NodeRT::Windows::Management::Deployment::InitSharedPackageContainerManager(target);
      NodeRT::Windows::Management::Deployment::InitSharedPackageContainerMember(target);
      NodeRT::Windows::Management::Deployment::InitStagePackageOptions(target);
      NodeRT::Windows::Management::Deployment::InitUpdateSharedPackageContainerOptions(target);
      NodeRT::Windows::Management::Deployment::InitUpdateSharedPackageContainerResult(target);


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



NODE_MODULE(binding, init)