// 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 UI { namespace ViewManagement { 
  v8::Local<v8::Value> WrapAccessibilitySettings(::Windows::UI::ViewManagement::AccessibilitySettings^ wintRtInstance);
  ::Windows::UI::ViewManagement::AccessibilitySettings^ UnwrapAccessibilitySettings(Local<Value> value);
  
  v8::Local<v8::Value> WrapActivationViewSwitcher(::Windows::UI::ViewManagement::ActivationViewSwitcher^ wintRtInstance);
  ::Windows::UI::ViewManagement::ActivationViewSwitcher^ UnwrapActivationViewSwitcher(Local<Value> value);
  
  v8::Local<v8::Value> WrapApplicationView(::Windows::UI::ViewManagement::ApplicationView^ wintRtInstance);
  ::Windows::UI::ViewManagement::ApplicationView^ UnwrapApplicationView(Local<Value> value);
  
  v8::Local<v8::Value> WrapApplicationViewConsolidatedEventArgs(::Windows::UI::ViewManagement::ApplicationViewConsolidatedEventArgs^ wintRtInstance);
  ::Windows::UI::ViewManagement::ApplicationViewConsolidatedEventArgs^ UnwrapApplicationViewConsolidatedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapApplicationViewScaling(::Windows::UI::ViewManagement::ApplicationViewScaling^ wintRtInstance);
  ::Windows::UI::ViewManagement::ApplicationViewScaling^ UnwrapApplicationViewScaling(Local<Value> value);
  
  v8::Local<v8::Value> WrapApplicationViewSwitcher(::Windows::UI::ViewManagement::ApplicationViewSwitcher^ wintRtInstance);
  ::Windows::UI::ViewManagement::ApplicationViewSwitcher^ UnwrapApplicationViewSwitcher(Local<Value> value);
  
  v8::Local<v8::Value> WrapApplicationViewTitleBar(::Windows::UI::ViewManagement::ApplicationViewTitleBar^ wintRtInstance);
  ::Windows::UI::ViewManagement::ApplicationViewTitleBar^ UnwrapApplicationViewTitleBar(Local<Value> value);
  
  v8::Local<v8::Value> WrapApplicationViewTransferContext(::Windows::UI::ViewManagement::ApplicationViewTransferContext^ wintRtInstance);
  ::Windows::UI::ViewManagement::ApplicationViewTransferContext^ UnwrapApplicationViewTransferContext(Local<Value> value);
  
  v8::Local<v8::Value> WrapInputPane(::Windows::UI::ViewManagement::InputPane^ wintRtInstance);
  ::Windows::UI::ViewManagement::InputPane^ UnwrapInputPane(Local<Value> value);
  
  v8::Local<v8::Value> WrapInputPaneVisibilityEventArgs(::Windows::UI::ViewManagement::InputPaneVisibilityEventArgs^ wintRtInstance);
  ::Windows::UI::ViewManagement::InputPaneVisibilityEventArgs^ UnwrapInputPaneVisibilityEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapProjectionManager(::Windows::UI::ViewManagement::ProjectionManager^ wintRtInstance);
  ::Windows::UI::ViewManagement::ProjectionManager^ UnwrapProjectionManager(Local<Value> value);
  
  v8::Local<v8::Value> WrapStatusBar(::Windows::UI::ViewManagement::StatusBar^ wintRtInstance);
  ::Windows::UI::ViewManagement::StatusBar^ UnwrapStatusBar(Local<Value> value);
  
  v8::Local<v8::Value> WrapStatusBarProgressIndicator(::Windows::UI::ViewManagement::StatusBarProgressIndicator^ wintRtInstance);
  ::Windows::UI::ViewManagement::StatusBarProgressIndicator^ UnwrapStatusBarProgressIndicator(Local<Value> value);
  
  v8::Local<v8::Value> WrapUISettings(::Windows::UI::ViewManagement::UISettings^ wintRtInstance);
  ::Windows::UI::ViewManagement::UISettings^ UnwrapUISettings(Local<Value> value);
  
  v8::Local<v8::Value> WrapUISettingsAnimationsEnabledChangedEventArgs(::Windows::UI::ViewManagement::UISettingsAnimationsEnabledChangedEventArgs^ wintRtInstance);
  ::Windows::UI::ViewManagement::UISettingsAnimationsEnabledChangedEventArgs^ UnwrapUISettingsAnimationsEnabledChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapUISettingsAutoHideScrollBarsChangedEventArgs(::Windows::UI::ViewManagement::UISettingsAutoHideScrollBarsChangedEventArgs^ wintRtInstance);
  ::Windows::UI::ViewManagement::UISettingsAutoHideScrollBarsChangedEventArgs^ UnwrapUISettingsAutoHideScrollBarsChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapUISettingsMessageDurationChangedEventArgs(::Windows::UI::ViewManagement::UISettingsMessageDurationChangedEventArgs^ wintRtInstance);
  ::Windows::UI::ViewManagement::UISettingsMessageDurationChangedEventArgs^ UnwrapUISettingsMessageDurationChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapUIViewSettings(::Windows::UI::ViewManagement::UIViewSettings^ wintRtInstance);
  ::Windows::UI::ViewManagement::UIViewSettings^ UnwrapUIViewSettings(Local<Value> value);
  
  v8::Local<v8::Value> WrapViewModePreferences(::Windows::UI::ViewManagement::ViewModePreferences^ wintRtInstance);
  ::Windows::UI::ViewManagement::ViewModePreferences^ UnwrapViewModePreferences(Local<Value> value);
  



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

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

    Nan::Set(exports, Nan::New<String>("ApplicationViewBoundsMode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("useVisible").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::ApplicationViewBoundsMode::UseVisible)));
    Nan::Set(enumObject, Nan::New<String>("useCoreWindow").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::ApplicationViewBoundsMode::UseCoreWindow)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ApplicationViewMode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("default").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::ApplicationViewMode::Default)));
    Nan::Set(enumObject, Nan::New<String>("compactOverlay").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::ApplicationViewMode::CompactOverlay)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ApplicationViewOrientation").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("landscape").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::ApplicationViewOrientation::Landscape)));
    Nan::Set(enumObject, Nan::New<String>("portrait").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::ApplicationViewOrientation::Portrait)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ApplicationViewState").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("fullScreenLandscape").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::ApplicationViewState::FullScreenLandscape)));
    Nan::Set(enumObject, Nan::New<String>("filled").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::ApplicationViewState::Filled)));
    Nan::Set(enumObject, Nan::New<String>("snapped").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::ApplicationViewState::Snapped)));
    Nan::Set(enumObject, Nan::New<String>("fullScreenPortrait").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::ApplicationViewState::FullScreenPortrait)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ApplicationViewSwitchingOptions").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("default").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::ApplicationViewSwitchingOptions::Default)));
    Nan::Set(enumObject, Nan::New<String>("skipAnimation").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::ApplicationViewSwitchingOptions::SkipAnimation)));
    Nan::Set(enumObject, Nan::New<String>("consolidateViews").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::ApplicationViewSwitchingOptions::ConsolidateViews)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ApplicationViewWindowingMode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("auto").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::ApplicationViewWindowingMode::Auto)));
    Nan::Set(enumObject, Nan::New<String>("preferredLaunchViewSize").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::ApplicationViewWindowingMode::PreferredLaunchViewSize)));
    Nan::Set(enumObject, Nan::New<String>("fullScreen").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::ApplicationViewWindowingMode::FullScreen)));
    Nan::Set(enumObject, Nan::New<String>("compactOverlay").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::ApplicationViewWindowingMode::CompactOverlay)));
    Nan::Set(enumObject, Nan::New<String>("maximized").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::ApplicationViewWindowingMode::Maximized)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("FullScreenSystemOverlayMode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("standard").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::FullScreenSystemOverlayMode::Standard)));
    Nan::Set(enumObject, Nan::New<String>("minimal").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::FullScreenSystemOverlayMode::Minimal)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("HandPreference").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("leftHanded").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::HandPreference::LeftHanded)));
    Nan::Set(enumObject, Nan::New<String>("rightHanded").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::HandPreference::RightHanded)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("UIColorType").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("background").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIColorType::Background)));
    Nan::Set(enumObject, Nan::New<String>("foreground").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIColorType::Foreground)));
    Nan::Set(enumObject, Nan::New<String>("accentDark3").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIColorType::AccentDark3)));
    Nan::Set(enumObject, Nan::New<String>("accentDark2").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIColorType::AccentDark2)));
    Nan::Set(enumObject, Nan::New<String>("accentDark1").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIColorType::AccentDark1)));
    Nan::Set(enumObject, Nan::New<String>("accent").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIColorType::Accent)));
    Nan::Set(enumObject, Nan::New<String>("accentLight1").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIColorType::AccentLight1)));
    Nan::Set(enumObject, Nan::New<String>("accentLight2").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIColorType::AccentLight2)));
    Nan::Set(enumObject, Nan::New<String>("accentLight3").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIColorType::AccentLight3)));
    Nan::Set(enumObject, Nan::New<String>("complement").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIColorType::Complement)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("UIElementType").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("activeCaption").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIElementType::ActiveCaption)));
    Nan::Set(enumObject, Nan::New<String>("background").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIElementType::Background)));
    Nan::Set(enumObject, Nan::New<String>("buttonFace").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIElementType::ButtonFace)));
    Nan::Set(enumObject, Nan::New<String>("buttonText").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIElementType::ButtonText)));
    Nan::Set(enumObject, Nan::New<String>("captionText").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIElementType::CaptionText)));
    Nan::Set(enumObject, Nan::New<String>("grayText").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIElementType::GrayText)));
    Nan::Set(enumObject, Nan::New<String>("highlight").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIElementType::Highlight)));
    Nan::Set(enumObject, Nan::New<String>("highlightText").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIElementType::HighlightText)));
    Nan::Set(enumObject, Nan::New<String>("hotlight").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIElementType::Hotlight)));
    Nan::Set(enumObject, Nan::New<String>("inactiveCaption").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIElementType::InactiveCaption)));
    Nan::Set(enumObject, Nan::New<String>("inactiveCaptionText").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIElementType::InactiveCaptionText)));
    Nan::Set(enumObject, Nan::New<String>("window").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIElementType::Window)));
    Nan::Set(enumObject, Nan::New<String>("windowText").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIElementType::WindowText)));
    Nan::Set(enumObject, Nan::New<String>("accentColor").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIElementType::AccentColor)));
    Nan::Set(enumObject, Nan::New<String>("textHigh").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIElementType::TextHigh)));
    Nan::Set(enumObject, Nan::New<String>("textMedium").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIElementType::TextMedium)));
    Nan::Set(enumObject, Nan::New<String>("textLow").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIElementType::TextLow)));
    Nan::Set(enumObject, Nan::New<String>("textContrastWithHigh").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIElementType::TextContrastWithHigh)));
    Nan::Set(enumObject, Nan::New<String>("nonTextHigh").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIElementType::NonTextHigh)));
    Nan::Set(enumObject, Nan::New<String>("nonTextMediumHigh").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIElementType::NonTextMediumHigh)));
    Nan::Set(enumObject, Nan::New<String>("nonTextMedium").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIElementType::NonTextMedium)));
    Nan::Set(enumObject, Nan::New<String>("nonTextMediumLow").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIElementType::NonTextMediumLow)));
    Nan::Set(enumObject, Nan::New<String>("nonTextLow").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIElementType::NonTextLow)));
    Nan::Set(enumObject, Nan::New<String>("pageBackground").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIElementType::PageBackground)));
    Nan::Set(enumObject, Nan::New<String>("popupBackground").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIElementType::PopupBackground)));
    Nan::Set(enumObject, Nan::New<String>("overlayOutsidePopup").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UIElementType::OverlayOutsidePopup)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("UserInteractionMode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("mouse").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UserInteractionMode::Mouse)));
    Nan::Set(enumObject, Nan::New<String>("touch").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::UserInteractionMode::Touch)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ViewSizePreference").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("default").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::ViewSizePreference::Default)));
    Nan::Set(enumObject, Nan::New<String>("useLess").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::ViewSizePreference::UseLess)));
    Nan::Set(enumObject, Nan::New<String>("useHalf").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::ViewSizePreference::UseHalf)));
    Nan::Set(enumObject, Nan::New<String>("useMore").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::ViewSizePreference::UseMore)));
    Nan::Set(enumObject, Nan::New<String>("useMinimum").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::ViewSizePreference::UseMinimum)));
    Nan::Set(enumObject, Nan::New<String>("useNone").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::ViewSizePreference::UseNone)));
    Nan::Set(enumObject, Nan::New<String>("custom").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::UI::ViewManagement::ViewSizePreference::Custom)));
  }

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

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

    return true;
  }

  ::Windows::UI::ViewManagement::ViewManagementViewScalingContract ViewManagementViewScalingContractFromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::UI::ViewManagement::ViewManagementViewScalingContract 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> ViewManagementViewScalingContractToJsObject(::Windows::UI::ViewManagement::ViewManagementViewScalingContract value) {
    EscapableHandleScope scope;

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


    return scope.Escape(obj);
  }

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

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

    return true;
  }

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

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

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

    return returnValue;
  }

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

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


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

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

    return true;
  }

  ::Windows::Foundation::Size SizeFromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::Foundation::Size 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> SizeToJsObject(::Windows::Foundation::Size value) {
    EscapableHandleScope scope;

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


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

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

    return true;
  }

  ::Windows::UI::Color ColorFromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::UI::Color 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> ColorToJsObject(::Windows::UI::Color value) {
    EscapableHandleScope scope;

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


    return scope.Escape(obj);
  }

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




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

          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("highContrast").ToLocalChecked(), HighContrastGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("highContrastScheme").ToLocalChecked(), HighContrastSchemeGetter);

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



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

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

    private:

      AccessibilitySettings(::Windows::UI::ViewManagement::AccessibilitySettings^ 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::UI::ViewManagement::AccessibilitySettings^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::AccessibilitySettings^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::AccessibilitySettings^>(info.This())) {
        return;
      }

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

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


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

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

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

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

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"highContrastChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::AccessibilitySettings^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        AccessibilitySettings *wrapper = AccessibilitySettings::Unwrap<AccessibilitySettings>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

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


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

                {
                  TryCatch tryCatch;


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"highContrastChanged", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::AccessibilitySettings^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          AccessibilitySettings *wrapper = AccessibilitySettings::Unwrap<AccessibilitySettings>(info.This());
          wrapper->_instance->HighContrastChanged::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

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

      friend v8::Local<v8::Value> WrapAccessibilitySettings(::Windows::UI::ViewManagement::AccessibilitySettings^ wintRtInstance);
      friend ::Windows::UI::ViewManagement::AccessibilitySettings^ UnwrapAccessibilitySettings(Local<Value> value);
  };

  Persistent<FunctionTemplate> AccessibilitySettings::s_constructorTemplate;

  v8::Local<v8::Value> WrapAccessibilitySettings(::Windows::UI::ViewManagement::AccessibilitySettings^ 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>(AccessibilitySettings::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::ViewManagement::AccessibilitySettings^ UnwrapAccessibilitySettings(Local<Value> value) {
     return AccessibilitySettings::Unwrap<AccessibilitySettings>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAccessibilitySettings(Local<Object> exports) {
    AccessibilitySettings::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "isViewPresentedOnActivationVirtualDesktop", IsViewPresentedOnActivationVirtualDesktop);
          

          
            Nan::SetPrototypeMethod(localRef, "showAsStandaloneAsync", ShowAsStandaloneAsync);
          



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



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

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

    private:

      ActivationViewSwitcher(::Windows::UI::ViewManagement::ActivationViewSwitcher^ 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::UI::ViewManagement::ActivationViewSwitcher^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ActivationViewSwitcher^>(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;
      }

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

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


      if (info.Length() == 2
        && info[0]->IsInt32())
      {
        try
        {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          op = wrapper->_instance->ShowAsStandaloneAsync(arg0);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && info[0]->IsInt32()
        && info[1]->IsInt32())
      {
        try
        {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          ::Windows::UI::ViewManagement::ViewSizePreference arg1 = static_cast<::Windows::UI::ViewManagement::ViewSizePreference>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          op = wrapper->_instance->ShowAsStandaloneAsync(arg0,arg1);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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


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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ActivationViewSwitcher^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          bool result;
          result = wrapper->_instance->IsViewPresentedOnActivationVirtualDesktop(arg0);
          info.GetReturnValue().Set(Nan::New<Boolean>(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }





    private:
      ::Windows::UI::ViewManagement::ActivationViewSwitcher^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapActivationViewSwitcher(::Windows::UI::ViewManagement::ActivationViewSwitcher^ wintRtInstance);
      friend ::Windows::UI::ViewManagement::ActivationViewSwitcher^ UnwrapActivationViewSwitcher(Local<Value> value);
  };

  Persistent<FunctionTemplate> ActivationViewSwitcher::s_constructorTemplate;

  v8::Local<v8::Value> WrapActivationViewSwitcher(::Windows::UI::ViewManagement::ActivationViewSwitcher^ 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>(ActivationViewSwitcher::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::ViewManagement::ActivationViewSwitcher^ UnwrapActivationViewSwitcher(Local<Value> value) {
     return ActivationViewSwitcher::Unwrap<ActivationViewSwitcher>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitActivationViewSwitcher(Local<Object> exports) {
    ActivationViewSwitcher::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "setDesiredBoundsMode", SetDesiredBoundsMode);
            Nan::SetPrototypeMethod(localRef, "tryEnterFullScreenMode", TryEnterFullScreenMode);
            Nan::SetPrototypeMethod(localRef, "exitFullScreenMode", ExitFullScreenMode);
            Nan::SetPrototypeMethod(localRef, "showStandardSystemOverlays", ShowStandardSystemOverlays);
            Nan::SetPrototypeMethod(localRef, "tryResizeView", TryResizeView);
            Nan::SetPrototypeMethod(localRef, "setPreferredMinSize", SetPreferredMinSize);
            Nan::SetPrototypeMethod(localRef, "isViewModeSupported", IsViewModeSupported);
            Nan::SetPrototypeMethod(localRef, "getDisplayRegions", GetDisplayRegions);
          

          
            Nan::SetPrototypeMethod(localRef, "tryEnterViewModeAsync", TryEnterViewModeAsync);
            Nan::SetPrototypeMethod(localRef, "tryConsolidateAsync", TryConsolidateAsync);
          

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

          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("title").ToLocalChecked(), TitleGetter, TitleSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isScreenCaptureEnabled").ToLocalChecked(), IsScreenCaptureEnabledGetter, IsScreenCaptureEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("adjacentToLeftDisplayEdge").ToLocalChecked(), AdjacentToLeftDisplayEdgeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("adjacentToRightDisplayEdge").ToLocalChecked(), AdjacentToRightDisplayEdgeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("id").ToLocalChecked(), IdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isFullScreen").ToLocalChecked(), IsFullScreenGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isOnLockScreen").ToLocalChecked(), IsOnLockScreenGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("orientation").ToLocalChecked(), OrientationGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("suppressSystemOverlays").ToLocalChecked(), SuppressSystemOverlaysGetter, SuppressSystemOverlaysSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("visibleBounds").ToLocalChecked(), VisibleBoundsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("desiredBoundsMode").ToLocalChecked(), DesiredBoundsModeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("fullScreenSystemOverlayMode").ToLocalChecked(), FullScreenSystemOverlayModeGetter, FullScreenSystemOverlayModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isFullScreenMode").ToLocalChecked(), IsFullScreenModeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("titleBar").ToLocalChecked(), TitleBarGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("viewMode").ToLocalChecked(), ViewModeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("persistedStateId").ToLocalChecked(), PersistedStateIdGetter, PersistedStateIdSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("windowingEnvironment").ToLocalChecked(), WindowingEnvironmentGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("uIContext").ToLocalChecked(), UIContextGetter);

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

        Nan::SetMethod(constructor, "clearAllPersistedState", ClearAllPersistedState);
        Nan::SetMethod(constructor, "clearPersistedState", ClearPersistedState);
        Nan::SetMethod(constructor, "tryUnsnapToFullscreen", TryUnsnapToFullscreen);
        Nan::SetMethod(constructor, "getApplicationViewIdForWindow", GetApplicationViewIdForWindow);
        Nan::SetMethod(constructor, "getForCurrentView", GetForCurrentView);
        Nan::SetMethod(constructor, "tryUnsnap", TryUnsnap);
        Nan::SetAccessor(constructor, Nan::New<String>("value").ToLocalChecked(), ValueGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("terminateAppOnFinalViewClose").ToLocalChecked(), TerminateAppOnFinalViewCloseGetter, TerminateAppOnFinalViewCloseSetter);
        Nan::SetAccessor(constructor, Nan::New<String>("preferredLaunchWindowingMode").ToLocalChecked(), PreferredLaunchWindowingModeGetter, PreferredLaunchWindowingModeSetter);
        Nan::SetAccessor(constructor, Nan::New<String>("preferredLaunchViewSize").ToLocalChecked(), PreferredLaunchViewSizeGetter, PreferredLaunchViewSizeSetter);


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

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

    private:

      ApplicationView(::Windows::UI::ViewManagement::ApplicationView^ 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::UI::ViewManagement::ApplicationView^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(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;
      }

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

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


      if (info.Length() == 2
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::UI::ViewManagement::ApplicationViewMode arg0 = static_cast<::Windows::UI::ViewManagement::ApplicationViewMode>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          op = wrapper->_instance->TryEnterViewModeAsync(arg0);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && info[0]->IsInt32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ViewModePreferences^>(info[1]))
      {
        try
        {
          ::Windows::UI::ViewManagement::ApplicationViewMode arg0 = static_cast<::Windows::UI::ViewManagement::ApplicationViewMode>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          ::Windows::UI::ViewManagement::ViewModePreferences^ arg1 = UnwrapViewModePreferences(info[1]);
          
          op = wrapper->_instance->TryEnterViewModeAsync(arg0,arg1);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(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;
      }

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

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


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

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

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


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


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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::UI::ViewManagement::ApplicationViewBoundsMode arg0 = static_cast<::Windows::UI::ViewManagement::ApplicationViewBoundsMode>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          bool result;
          result = wrapper->_instance->SetDesiredBoundsMode(arg0);
          info.GetReturnValue().Set(Nan::New<Boolean>(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void TryEnterFullScreenMode(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && NodeRT::Utils::IsSize(info[0]))
      {
        try
        {
          ::Windows::Foundation::Size arg0 = NodeRT::Utils::SizeFromJs(info[0]);
          
          bool result;
          result = wrapper->_instance->TryResizeView(arg0);
          info.GetReturnValue().Set(Nan::New<Boolean>(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void SetPreferredMinSize(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && NodeRT::Utils::IsSize(info[0]))
      {
        try
        {
          ::Windows::Foundation::Size arg0 = NodeRT::Utils::SizeFromJs(info[0]);
          
          wrapper->_instance->SetPreferredMinSize(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 IsViewModeSupported(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::UI::ViewManagement::ApplicationViewMode arg0 = static_cast<::Windows::UI::ViewManagement::ApplicationViewMode>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          bool result;
          result = wrapper->_instance->IsViewModeSupported(arg0);
          info.GetReturnValue().Set(Nan::New<Boolean>(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetDisplayRegions(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Windows::UI::WindowManagement::DisplayRegion^>^ result;
          result = wrapper->_instance->GetDisplayRegions();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::UI::WindowManagement::DisplayRegion^>::CreateVectorViewWrapper(result, 
            [](::Windows::UI::WindowManagement::DisplayRegion^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.UI.WindowManagement", "DisplayRegion", val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::WindowManagement::DisplayRegion^>(value);
            },
            [](Local<Value> value) -> ::Windows::UI::WindowManagement::DisplayRegion^ {
              return dynamic_cast<::Windows::UI::WindowManagement::DisplayRegion^>(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 ClearAllPersistedState(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::UI::ViewManagement::ApplicationView::ClearAllPersistedState();
          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 ClearPersistedState(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::UI::ViewManagement::ApplicationView::ClearPersistedState(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 TryUnsnapToFullscreen(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          bool result;
          result = ::Windows::UI::ViewManagement::ApplicationView::TryUnsnapToFullscreen();
          info.GetReturnValue().Set(Nan::New<Boolean>(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::Core::ICoreWindow^>(info[0]))
      {
        try
        {
          ::Windows::UI::Core::ICoreWindow^ arg0 = dynamic_cast<::Windows::UI::Core::ICoreWindow^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          int result;
          result = ::Windows::UI::ViewManagement::ApplicationView::GetApplicationViewIdForWindow(arg0);
          info.GetReturnValue().Set(Nan::New<Integer>(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 GetForCurrentView(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::UI::ViewManagement::ApplicationView^ result;
          result = ::Windows::UI::ViewManagement::ApplicationView::GetForCurrentView();
          info.GetReturnValue().Set(WrapApplicationView(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 TryUnsnap(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          bool result;
          result = ::Windows::UI::ViewManagement::ApplicationView::TryUnsnap();
          info.GetReturnValue().Set(Nan::New<Boolean>(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::UI::ViewManagement::ApplicationViewTitleBar^ result = wrapper->_instance->TitleBar;
        info.GetReturnValue().Set(WrapApplicationViewTitleBar(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ViewModeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This())) {
        return;
      }

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

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


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

      try
      {
        ::Windows::UI::ViewManagement::ApplicationViewState result = ::Windows::UI::ViewManagement::ApplicationView::Value;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        bool result = ::Windows::UI::ViewManagement::ApplicationView::TerminateAppOnFinalViewClose;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    static void TerminateAppOnFinalViewCloseSetter(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;
      }

      try {


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

        ::Windows::UI::ViewManagement::ApplicationView::TerminateAppOnFinalViewClose = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      

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

      try
      {
        ::Windows::UI::ViewManagement::ApplicationViewWindowingMode result = ::Windows::UI::ViewManagement::ApplicationView::PreferredLaunchWindowingMode;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

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

      try {


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

        ::Windows::UI::ViewManagement::ApplicationView::PreferredLaunchWindowingMode = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      

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

      try
      {
        ::Windows::Foundation::Size result = ::Windows::UI::ViewManagement::ApplicationView::PreferredLaunchViewSize;
        info.GetReturnValue().Set(NodeRT::Utils::SizeToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

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

      try {


        ::Windows::Foundation::Size winRtValue = NodeRT::Utils::SizeFromJs(value);

        ::Windows::UI::ViewManagement::ApplicationView::PreferredLaunchViewSize = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      

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

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

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

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

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"consolidated", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        ApplicationView *wrapper = ApplicationView::Unwrap<ApplicationView>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->Consolidated::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::ViewManagement::ApplicationView^, ::Windows::UI::ViewManagement::ApplicationViewConsolidatedEventArgs^>(
            [callbackObjPtr](::Windows::UI::ViewManagement::ApplicationView^ arg0, ::Windows::UI::ViewManagement::ApplicationViewConsolidatedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapApplicationView(arg0);
                  wrappedArg1 = WrapApplicationViewConsolidatedEventArgs(arg1);


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

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

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"visibleBoundsChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        ApplicationView *wrapper = ApplicationView::Unwrap<ApplicationView>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

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


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

                {
                  TryCatch tryCatch;


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"consolidated", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          ApplicationView *wrapper = ApplicationView::Unwrap<ApplicationView>(info.This());
          wrapper->_instance->Consolidated::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"visibleBoundsChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationView^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          ApplicationView *wrapper = ApplicationView::Unwrap<ApplicationView>(info.This());
          wrapper->_instance->VisibleBoundsChanged::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

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

      friend v8::Local<v8::Value> WrapApplicationView(::Windows::UI::ViewManagement::ApplicationView^ wintRtInstance);
      friend ::Windows::UI::ViewManagement::ApplicationView^ UnwrapApplicationView(Local<Value> value);
  };

  Persistent<FunctionTemplate> ApplicationView::s_constructorTemplate;

  v8::Local<v8::Value> WrapApplicationView(::Windows::UI::ViewManagement::ApplicationView^ 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>(ApplicationView::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::ViewManagement::ApplicationView^ UnwrapApplicationView(Local<Value> value) {
     return ApplicationView::Unwrap<ApplicationView>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitApplicationView(Local<Object> exports) {
    ApplicationView::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isUserInitiated").ToLocalChecked(), IsUserInitiatedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isAppInitiated").ToLocalChecked(), IsAppInitiatedGetter);

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



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

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

    private:

      ApplicationViewConsolidatedEventArgs(::Windows::UI::ViewManagement::ApplicationViewConsolidatedEventArgs^ 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::UI::ViewManagement::ApplicationViewConsolidatedEventArgs^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationViewConsolidatedEventArgs^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationViewConsolidatedEventArgs^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::UI::ViewManagement::ApplicationViewConsolidatedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapApplicationViewConsolidatedEventArgs(::Windows::UI::ViewManagement::ApplicationViewConsolidatedEventArgs^ wintRtInstance);
      friend ::Windows::UI::ViewManagement::ApplicationViewConsolidatedEventArgs^ UnwrapApplicationViewConsolidatedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> ApplicationViewConsolidatedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapApplicationViewConsolidatedEventArgs(::Windows::UI::ViewManagement::ApplicationViewConsolidatedEventArgs^ 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>(ApplicationViewConsolidatedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::ViewManagement::ApplicationViewConsolidatedEventArgs^ UnwrapApplicationViewConsolidatedEventArgs(Local<Value> value) {
     return ApplicationViewConsolidatedEventArgs::Unwrap<ApplicationViewConsolidatedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitApplicationViewConsolidatedEventArgs(Local<Object> exports) {
    ApplicationViewConsolidatedEventArgs::Init(exports);
  }

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






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

        Nan::SetMethod(constructor, "trySetDisableLayoutScaling", TrySetDisableLayoutScaling);
        Nan::SetAccessor(constructor, Nan::New<String>("disableLayoutScaling").ToLocalChecked(), DisableLayoutScalingGetter);


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

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

    private:

      ApplicationViewScaling(::Windows::UI::ViewManagement::ApplicationViewScaling^ 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::UI::ViewManagement::ApplicationViewScaling^ winRtInstance;


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

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

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





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

      if (info.Length() == 1
        && info[0]->IsBoolean())
      {
        try
        {
          bool arg0 = Nan::To<bool>(info[0]).FromMaybe(false);
          
          bool result;
          result = ::Windows::UI::ViewManagement::ApplicationViewScaling::TrySetDisableLayoutScaling(arg0);
          info.GetReturnValue().Set(Nan::New<Boolean>(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



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

      try
      {
        bool result = ::Windows::UI::ViewManagement::ApplicationViewScaling::DisableLayoutScaling;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    private:
      ::Windows::UI::ViewManagement::ApplicationViewScaling^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapApplicationViewScaling(::Windows::UI::ViewManagement::ApplicationViewScaling^ wintRtInstance);
      friend ::Windows::UI::ViewManagement::ApplicationViewScaling^ UnwrapApplicationViewScaling(Local<Value> value);
  };

  Persistent<FunctionTemplate> ApplicationViewScaling::s_constructorTemplate;

  v8::Local<v8::Value> WrapApplicationViewScaling(::Windows::UI::ViewManagement::ApplicationViewScaling^ 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>(ApplicationViewScaling::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::ViewManagement::ApplicationViewScaling^ UnwrapApplicationViewScaling(Local<Value> value) {
     return ApplicationViewScaling::Unwrap<ApplicationViewScaling>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitApplicationViewScaling(Local<Object> exports) {
    ApplicationViewScaling::Init(exports);
  }

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

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





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

        Nan::SetMethod(constructor, "disableSystemViewActivationPolicy", DisableSystemViewActivationPolicy);
        Nan::SetMethod(constructor, "disableShowingMainViewOnActivation", DisableShowingMainViewOnActivation);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(TryShowAsViewModeAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("tryShowAsViewModeAsync").ToLocalChecked(), func);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(TryShowAsStandaloneAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("tryShowAsStandaloneAsync").ToLocalChecked(), func);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(SwitchAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("switchAsync").ToLocalChecked(), func);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(PrepareForCustomAnimatedSwitchAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("prepareForCustomAnimatedSwitchAsync").ToLocalChecked(), func);


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

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

    private:

      ApplicationViewSwitcher(::Windows::UI::ViewManagement::ApplicationViewSwitcher^ 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::UI::ViewManagement::ApplicationViewSwitcher^ winRtInstance;


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

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

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




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

      if (info.Length() == 0 || !info[info.Length() -1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: No callback was given")));
        return;
      }

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


      if (info.Length() == 3
          && info[0]->IsInt32()
          && info[1]->IsInt32())
      {
        try
        {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          ::Windows::UI::ViewManagement::ApplicationViewMode arg1 = static_cast<::Windows::UI::ViewManagement::ApplicationViewMode>(Nan::To<int32_t>(info[1]).FromMaybe(0));
            
          op = ::Windows::UI::ViewManagement::ApplicationViewSwitcher::TryShowAsViewModeAsync(arg0,arg1);
        } catch (Platform::Exception ^exception) {
            NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
            return;
        }
      }
      else if (info.Length() == 4
          && info[0]->IsInt32()
          && info[1]->IsInt32()
          && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ViewModePreferences^>(info[2]))
      {
        try
        {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          ::Windows::UI::ViewManagement::ApplicationViewMode arg1 = static_cast<::Windows::UI::ViewManagement::ApplicationViewMode>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          ::Windows::UI::ViewManagement::ViewModePreferences^ arg2 = UnwrapViewModePreferences(info[2]);
            
          op = ::Windows::UI::ViewManagement::ApplicationViewSwitcher::TryShowAsViewModeAsync(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<bool> t)
      {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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


            invokeCallback(_countof(args), args);
          });
        }
        catch (Platform::Exception^ exception)
        {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {

            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

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

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

      if (info.Length() == 0 || !info[info.Length() -1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: No callback was given")));
        return;
      }

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


      if (info.Length() == 2
          && info[0]->IsInt32())
      {
        try
        {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
            
          op = ::Windows::UI::ViewManagement::ApplicationViewSwitcher::TryShowAsStandaloneAsync(arg0);
        } catch (Platform::Exception ^exception) {
            NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
            return;
        }
      }
      else if (info.Length() == 3
          && info[0]->IsInt32()
          && info[1]->IsInt32())
      {
        try
        {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          ::Windows::UI::ViewManagement::ViewSizePreference arg1 = static_cast<::Windows::UI::ViewManagement::ViewSizePreference>(Nan::To<int32_t>(info[1]).FromMaybe(0));
            
          op = ::Windows::UI::ViewManagement::ApplicationViewSwitcher::TryShowAsStandaloneAsync(arg0,arg1);
        } catch (Platform::Exception ^exception) {
            NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
            return;
        }
      }
      else if (info.Length() == 5
          && info[0]->IsInt32()
          && info[1]->IsInt32()
          && info[2]->IsInt32()
          && info[3]->IsInt32())
      {
        try
        {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          ::Windows::UI::ViewManagement::ViewSizePreference arg1 = static_cast<::Windows::UI::ViewManagement::ViewSizePreference>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          int arg2 = static_cast<int>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          ::Windows::UI::ViewManagement::ViewSizePreference arg3 = static_cast<::Windows::UI::ViewManagement::ViewSizePreference>(Nan::To<int32_t>(info[3]).FromMaybe(0));
            
          op = ::Windows::UI::ViewManagement::ApplicationViewSwitcher::TryShowAsStandaloneAsync(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<bool> t)
      {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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


            invokeCallback(_countof(args), args);
          });
        }
        catch (Platform::Exception^ exception)
        {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {

            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

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

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

      if (info.Length() == 0 || !info[info.Length() -1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: No callback was given")));
        return;
      }

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


      if (info.Length() == 2
          && info[0]->IsInt32())
      {
        try
        {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
            
          op = ::Windows::UI::ViewManagement::ApplicationViewSwitcher::SwitchAsync(arg0);
        } catch (Platform::Exception ^exception) {
            NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
            return;
        }
      }
      else if (info.Length() == 3
          && info[0]->IsInt32()
          && info[1]->IsInt32())
      {
        try
        {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          int arg1 = static_cast<int>(Nan::To<int32_t>(info[1]).FromMaybe(0));
            
          op = ::Windows::UI::ViewManagement::ApplicationViewSwitcher::SwitchAsync(arg0,arg1);
        } catch (Platform::Exception ^exception) {
            NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
            return;
        }
      }
      else if (info.Length() == 4
          && info[0]->IsInt32()
          && info[1]->IsInt32()
          && info[2]->IsInt32())
      {
        try
        {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          int arg1 = static_cast<int>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          ::Windows::UI::ViewManagement::ApplicationViewSwitchingOptions arg2 = static_cast<::Windows::UI::ViewManagement::ApplicationViewSwitchingOptions>(Nan::To<int32_t>(info[2]).FromMaybe(0));
            
          op = ::Windows::UI::ViewManagement::ApplicationViewSwitcher::SwitchAsync(arg0,arg1,arg2);
        } catch (Platform::Exception ^exception) {
            NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
            return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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


            invokeCallback(_countof(args), args);
          });
        }
        catch (Platform::Exception^ exception)
        {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {

            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

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

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

      if (info.Length() == 0 || !info[info.Length() -1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: No callback was given")));
        return;
      }

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


      if (info.Length() == 4
          && info[0]->IsInt32()
          && info[1]->IsInt32()
          && info[2]->IsInt32())
      {
        try
        {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          int arg1 = static_cast<int>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          ::Windows::UI::ViewManagement::ApplicationViewSwitchingOptions arg2 = static_cast<::Windows::UI::ViewManagement::ApplicationViewSwitchingOptions>(Nan::To<int32_t>(info[2]).FromMaybe(0));
            
          op = ::Windows::UI::ViewManagement::ApplicationViewSwitcher::PrepareForCustomAnimatedSwitchAsync(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<bool> t)
      {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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


            invokeCallback(_countof(args), args);
          });
        }
        catch (Platform::Exception^ exception)
        {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {

            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

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


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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::UI::ViewManagement::ApplicationViewSwitcher::DisableSystemViewActivationPolicy();
          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 DisableShowingMainViewOnActivation(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::UI::ViewManagement::ApplicationViewSwitcher::DisableShowingMainViewOnActivation();
          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::UI::ViewManagement::ApplicationViewSwitcher^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapApplicationViewSwitcher(::Windows::UI::ViewManagement::ApplicationViewSwitcher^ wintRtInstance);
      friend ::Windows::UI::ViewManagement::ApplicationViewSwitcher^ UnwrapApplicationViewSwitcher(Local<Value> value);
  };

  Persistent<FunctionTemplate> ApplicationViewSwitcher::s_constructorTemplate;

  v8::Local<v8::Value> WrapApplicationViewSwitcher(::Windows::UI::ViewManagement::ApplicationViewSwitcher^ 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>(ApplicationViewSwitcher::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::ViewManagement::ApplicationViewSwitcher^ UnwrapApplicationViewSwitcher(Local<Value> value) {
     return ApplicationViewSwitcher::Unwrap<ApplicationViewSwitcher>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitApplicationViewSwitcher(Local<Object> exports) {
    ApplicationViewSwitcher::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("inactiveForegroundColor").ToLocalChecked(), InactiveForegroundColorGetter, InactiveForegroundColorSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("inactiveBackgroundColor").ToLocalChecked(), InactiveBackgroundColorGetter, InactiveBackgroundColorSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("foregroundColor").ToLocalChecked(), ForegroundColorGetter, ForegroundColorSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("buttonPressedForegroundColor").ToLocalChecked(), ButtonPressedForegroundColorGetter, ButtonPressedForegroundColorSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("buttonPressedBackgroundColor").ToLocalChecked(), ButtonPressedBackgroundColorGetter, ButtonPressedBackgroundColorSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("buttonInactiveForegroundColor").ToLocalChecked(), ButtonInactiveForegroundColorGetter, ButtonInactiveForegroundColorSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("buttonInactiveBackgroundColor").ToLocalChecked(), ButtonInactiveBackgroundColorGetter, ButtonInactiveBackgroundColorSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("buttonHoverForegroundColor").ToLocalChecked(), ButtonHoverForegroundColorGetter, ButtonHoverForegroundColorSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("buttonHoverBackgroundColor").ToLocalChecked(), ButtonHoverBackgroundColorGetter, ButtonHoverBackgroundColorSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("buttonForegroundColor").ToLocalChecked(), ButtonForegroundColorGetter, ButtonForegroundColorSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("buttonBackgroundColor").ToLocalChecked(), ButtonBackgroundColorGetter, ButtonBackgroundColorSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("backgroundColor").ToLocalChecked(), BackgroundColorGetter, BackgroundColorSetter);

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



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

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

    private:

      ApplicationViewTitleBar(::Windows::UI::ViewManagement::ApplicationViewTitleBar^ 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::UI::ViewManagement::ApplicationViewTitleBar^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationViewTitleBar^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->InactiveForegroundColor;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void InactiveForegroundColorSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationViewTitleBar^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationViewTitleBar^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->InactiveBackgroundColor;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void InactiveBackgroundColorSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationViewTitleBar^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationViewTitleBar^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->ForegroundColor;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ForegroundColorSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationViewTitleBar^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationViewTitleBar^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->ButtonPressedForegroundColor;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ButtonPressedForegroundColorSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationViewTitleBar^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationViewTitleBar^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->ButtonPressedBackgroundColor;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ButtonPressedBackgroundColorSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationViewTitleBar^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationViewTitleBar^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->ButtonInactiveForegroundColor;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ButtonInactiveForegroundColorSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationViewTitleBar^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationViewTitleBar^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->ButtonInactiveBackgroundColor;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ButtonInactiveBackgroundColorSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationViewTitleBar^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationViewTitleBar^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->ButtonHoverForegroundColor;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ButtonHoverForegroundColorSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationViewTitleBar^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationViewTitleBar^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->ButtonHoverBackgroundColor;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ButtonHoverBackgroundColorSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationViewTitleBar^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationViewTitleBar^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->ButtonForegroundColor;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ButtonForegroundColorSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationViewTitleBar^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationViewTitleBar^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->ButtonBackgroundColor;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ButtonBackgroundColorSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationViewTitleBar^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationViewTitleBar^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->BackgroundColor;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BackgroundColorSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationViewTitleBar^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

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


    private:
      ::Windows::UI::ViewManagement::ApplicationViewTitleBar^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapApplicationViewTitleBar(::Windows::UI::ViewManagement::ApplicationViewTitleBar^ wintRtInstance);
      friend ::Windows::UI::ViewManagement::ApplicationViewTitleBar^ UnwrapApplicationViewTitleBar(Local<Value> value);
  };

  Persistent<FunctionTemplate> ApplicationViewTitleBar::s_constructorTemplate;

  v8::Local<v8::Value> WrapApplicationViewTitleBar(::Windows::UI::ViewManagement::ApplicationViewTitleBar^ 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>(ApplicationViewTitleBar::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::ViewManagement::ApplicationViewTitleBar^ UnwrapApplicationViewTitleBar(Local<Value> value) {
     return ApplicationViewTitleBar::Unwrap<ApplicationViewTitleBar>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitApplicationViewTitleBar(Local<Object> exports) {
    ApplicationViewTitleBar::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("viewId").ToLocalChecked(), ViewIdGetter, ViewIdSetter);

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

        Nan::SetAccessor(constructor, Nan::New<String>("dataPackageFormatId").ToLocalChecked(), DataPackageFormatIdGetter);


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

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

    private:

      ApplicationViewTransferContext(::Windows::UI::ViewManagement::ApplicationViewTransferContext^ 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::UI::ViewManagement::ApplicationViewTransferContext^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ApplicationViewTransferContext^>(info.This())) {
        return;
      }

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

      try  {
        int result = wrapper->_instance->ViewId;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ViewIdSetter(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::UI::ViewManagement::ApplicationViewTransferContext^>(info.This())) {
        return;
      }

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

      try {

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

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


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

      try
      {
        Platform::String^ result = ::Windows::UI::ViewManagement::ApplicationViewTransferContext::DataPackageFormatId;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    private:
      ::Windows::UI::ViewManagement::ApplicationViewTransferContext^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapApplicationViewTransferContext(::Windows::UI::ViewManagement::ApplicationViewTransferContext^ wintRtInstance);
      friend ::Windows::UI::ViewManagement::ApplicationViewTransferContext^ UnwrapApplicationViewTransferContext(Local<Value> value);
  };

  Persistent<FunctionTemplate> ApplicationViewTransferContext::s_constructorTemplate;

  v8::Local<v8::Value> WrapApplicationViewTransferContext(::Windows::UI::ViewManagement::ApplicationViewTransferContext^ 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>(ApplicationViewTransferContext::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::ViewManagement::ApplicationViewTransferContext^ UnwrapApplicationViewTransferContext(Local<Value> value) {
     return ApplicationViewTransferContext::Unwrap<ApplicationViewTransferContext>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitApplicationViewTransferContext(Local<Object> exports) {
    ApplicationViewTransferContext::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "tryShow", TryShow);
            Nan::SetPrototypeMethod(localRef, "tryHide", TryHide);
          


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

          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("occludedRect").ToLocalChecked(), OccludedRectGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("visible").ToLocalChecked(), VisibleGetter, VisibleSetter);

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

        Nan::SetMethod(constructor, "getForUIContext", GetForUIContext);
        Nan::SetMethod(constructor, "getForCurrentView", GetForCurrentView);


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

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

    private:

      InputPane(::Windows::UI::ViewManagement::InputPane^ 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::UI::ViewManagement::InputPane^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::InputPane^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::InputPane^>(info.This())) {
        return;
      }

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

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



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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::UIContext^>(info[0]))
      {
        try
        {
          ::Windows::UI::UIContext^ arg0 = dynamic_cast<::Windows::UI::UIContext^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::UI::ViewManagement::InputPane^ result;
          result = ::Windows::UI::ViewManagement::InputPane::GetForUIContext(arg0);
          info.GetReturnValue().Set(WrapInputPane(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 GetForCurrentView(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::UI::ViewManagement::InputPane^ result;
          result = ::Windows::UI::ViewManagement::InputPane::GetForCurrentView();
          info.GetReturnValue().Set(WrapInputPane(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 OccludedRectGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::InputPane^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::InputPane^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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


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

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

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

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

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"hiding", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::InputPane^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        InputPane *wrapper = InputPane::Unwrap<InputPane>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->Hiding::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::ViewManagement::InputPane^, ::Windows::UI::ViewManagement::InputPaneVisibilityEventArgs^>(
            [callbackObjPtr](::Windows::UI::ViewManagement::InputPane^ arg0, ::Windows::UI::ViewManagement::InputPaneVisibilityEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapInputPane(arg0);
                  wrappedArg1 = WrapInputPaneVisibilityEventArgs(arg1);


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

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

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"showing", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::InputPane^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        InputPane *wrapper = InputPane::Unwrap<InputPane>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->Showing::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::ViewManagement::InputPane^, ::Windows::UI::ViewManagement::InputPaneVisibilityEventArgs^>(
            [callbackObjPtr](::Windows::UI::ViewManagement::InputPane^ arg0, ::Windows::UI::ViewManagement::InputPaneVisibilityEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapInputPane(arg0);
                  wrappedArg1 = WrapInputPaneVisibilityEventArgs(arg1);


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"hiding", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::InputPane^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          InputPane *wrapper = InputPane::Unwrap<InputPane>(info.This());
          wrapper->_instance->Hiding::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"showing", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::InputPane^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          InputPane *wrapper = InputPane::Unwrap<InputPane>(info.This());
          wrapper->_instance->Showing::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

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

      friend v8::Local<v8::Value> WrapInputPane(::Windows::UI::ViewManagement::InputPane^ wintRtInstance);
      friend ::Windows::UI::ViewManagement::InputPane^ UnwrapInputPane(Local<Value> value);
  };

  Persistent<FunctionTemplate> InputPane::s_constructorTemplate;

  v8::Local<v8::Value> WrapInputPane(::Windows::UI::ViewManagement::InputPane^ 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>(InputPane::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::ViewManagement::InputPane^ UnwrapInputPane(Local<Value> value) {
     return InputPane::Unwrap<InputPane>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInputPane(Local<Object> exports) {
    InputPane::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("ensuredFocusedElementInView").ToLocalChecked(), EnsuredFocusedElementInViewGetter, EnsuredFocusedElementInViewSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("occludedRect").ToLocalChecked(), OccludedRectGetter);

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



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

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

    private:

      InputPaneVisibilityEventArgs(::Windows::UI::ViewManagement::InputPaneVisibilityEventArgs^ 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::UI::ViewManagement::InputPaneVisibilityEventArgs^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::InputPaneVisibilityEventArgs^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::InputPaneVisibilityEventArgs^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Rect result = wrapper->_instance->OccludedRect;
        info.GetReturnValue().Set(NodeRT::Utils::RectToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::UI::ViewManagement::InputPaneVisibilityEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapInputPaneVisibilityEventArgs(::Windows::UI::ViewManagement::InputPaneVisibilityEventArgs^ wintRtInstance);
      friend ::Windows::UI::ViewManagement::InputPaneVisibilityEventArgs^ UnwrapInputPaneVisibilityEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> InputPaneVisibilityEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapInputPaneVisibilityEventArgs(::Windows::UI::ViewManagement::InputPaneVisibilityEventArgs^ 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>(InputPaneVisibilityEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::ViewManagement::InputPaneVisibilityEventArgs^ UnwrapInputPaneVisibilityEventArgs(Local<Value> value) {
     return InputPaneVisibilityEventArgs::Unwrap<InputPaneVisibilityEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitInputPaneVisibilityEventArgs(Local<Object> exports) {
    InputPaneVisibilityEventArgs::Init(exports);
  }

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

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





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

        Nan::SetMethod(constructor, "getDeviceSelector", GetDeviceSelector);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(StartProjectingAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("startProjectingAsync").ToLocalChecked(), func);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(RequestStartProjectingAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("requestStartProjectingAsync").ToLocalChecked(), func);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(SwapDisplaysForViewsAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("swapDisplaysForViewsAsync").ToLocalChecked(), func);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(StopProjectingAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("stopProjectingAsync").ToLocalChecked(), func);
        Nan::SetAccessor(constructor, Nan::New<String>("projectionDisplayAvailable").ToLocalChecked(), ProjectionDisplayAvailableGetter);
        
              Local<Function> addListenerFunc = Nan::GetFunction(Nan::New<FunctionTemplate>(AddListener)).ToLocalChecked();
              Nan::Set(constructor, Nan::New<String>("addListener").ToLocalChecked(), addListenerFunc);
              Nan::Set(constructor, Nan::New<String>("on").ToLocalChecked(), addListenerFunc);
              Local<Function> removeListenerFunc = Nan::GetFunction(Nan::New<FunctionTemplate>(RemoveListener)).ToLocalChecked();
              Nan::Set(constructor, Nan::New<String>("removeListener").ToLocalChecked(), removeListenerFunc);
              Nan::Set(constructor, Nan::New<String>("off").ToLocalChecked(), removeListenerFunc);


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

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

    private:

      ProjectionManager(::Windows::UI::ViewManagement::ProjectionManager^ 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::UI::ViewManagement::ProjectionManager^ winRtInstance;


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

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

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




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

      if (info.Length() == 0 || !info[info.Length() -1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: No callback was given")));
        return;
      }

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


      if (info.Length() == 4
          && info[0]->IsInt32()
          && info[1]->IsInt32()
          && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Devices::Enumeration::DeviceInformation^>(info[2]))
      {
        try
        {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          int arg1 = static_cast<int>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          ::Windows::Devices::Enumeration::DeviceInformation^ arg2 = dynamic_cast<::Windows::Devices::Enumeration::DeviceInformation^>(NodeRT::Utils::GetObjectInstance(info[2]));
            
          op = ::Windows::UI::ViewManagement::ProjectionManager::StartProjectingAsync(arg0,arg1,arg2);
        } catch (Platform::Exception ^exception) {
            NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
            return;
        }
      }
      else if (info.Length() == 3
          && info[0]->IsInt32()
          && info[1]->IsInt32())
      {
        try
        {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          int arg1 = static_cast<int>(Nan::To<int32_t>(info[1]).FromMaybe(0));
            
          op = ::Windows::UI::ViewManagement::ProjectionManager::StartProjectingAsync(arg0,arg1);
        } catch (Platform::Exception ^exception) {
            NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
            return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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


            invokeCallback(_countof(args), args);
          });
        }
        catch (Platform::Exception^ exception)
        {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {

            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

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

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

      if (info.Length() == 0 || !info[info.Length() -1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: No callback was given")));
        return;
      }

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


      if (info.Length() == 4
          && info[0]->IsInt32()
          && info[1]->IsInt32()
          && NodeRT::Utils::IsRect(info[2]))
      {
        try
        {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          int arg1 = static_cast<int>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          ::Windows::Foundation::Rect arg2 = NodeRT::Utils::RectFromJs(info[2]);
            
          op = ::Windows::UI::ViewManagement::ProjectionManager::RequestStartProjectingAsync(arg0,arg1,arg2);
        } catch (Platform::Exception ^exception) {
            NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
            return;
        }
      }
      else if (info.Length() == 5
          && info[0]->IsInt32()
          && info[1]->IsInt32()
          && NodeRT::Utils::IsRect(info[2])
          && info[3]->IsInt32())
      {
        try
        {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          int arg1 = static_cast<int>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          ::Windows::Foundation::Rect arg2 = NodeRT::Utils::RectFromJs(info[2]);
          ::Windows::UI::Popups::Placement arg3 = static_cast<::Windows::UI::Popups::Placement>(Nan::To<int32_t>(info[3]).FromMaybe(0));
            
          op = ::Windows::UI::ViewManagement::ProjectionManager::RequestStartProjectingAsync(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<bool> t)
      {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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


            invokeCallback(_countof(args), args);
          });
        }
        catch (Platform::Exception^ exception)
        {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {

            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

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

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

      if (info.Length() == 0 || !info[info.Length() -1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: No callback was given")));
        return;
      }

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


      if (info.Length() == 3
          && info[0]->IsInt32()
          && info[1]->IsInt32())
      {
        try
        {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          int arg1 = static_cast<int>(Nan::To<int32_t>(info[1]).FromMaybe(0));
            
          op = ::Windows::UI::ViewManagement::ProjectionManager::SwapDisplaysForViewsAsync(arg0,arg1);
        } catch (Platform::Exception ^exception) {
            NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
            return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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


            invokeCallback(_countof(args), args);
          });
        }
        catch (Platform::Exception^ exception)
        {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {

            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

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

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

      if (info.Length() == 0 || !info[info.Length() -1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: No callback was given")));
        return;
      }

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


      if (info.Length() == 3
          && info[0]->IsInt32()
          && info[1]->IsInt32())
      {
        try
        {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          int arg1 = static_cast<int>(Nan::To<int32_t>(info[1]).FromMaybe(0));
            
          op = ::Windows::UI::ViewManagement::ProjectionManager::StopProjectingAsync(arg0,arg1);
        } catch (Platform::Exception ^exception) {
            NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
            return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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


            invokeCallback(_countof(args), args);
          });
        }
        catch (Platform::Exception^ exception)
        {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {

            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

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


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

      if (info.Length() == 0)
      {
        try
        {
          Platform::String^ result;
          result = ::Windows::UI::ViewManagement::ProjectionManager::GetDeviceSelector();
          info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



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

      try
      {
        bool result = ::Windows::UI::ViewManagement::ProjectionManager::ProjectionDisplayAvailable;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

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

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

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

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"projectionDisplayAvailableChanged", str))
      {
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = ::Windows::UI::ViewManagement::ProjectionManager::ProjectionDisplayAvailableChanged::add(
            ref new ::Windows::Foundation::EventHandler<::Platform::Object^>(
            [callbackObjPtr](::Platform::Object^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"projectionDisplayAvailableChanged", str)) {
          ::Windows::UI::ViewManagement::ProjectionManager::ProjectionDisplayAvailableChanged::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

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

      friend v8::Local<v8::Value> WrapProjectionManager(::Windows::UI::ViewManagement::ProjectionManager^ wintRtInstance);
      friend ::Windows::UI::ViewManagement::ProjectionManager^ UnwrapProjectionManager(Local<Value> value);
  };

  Persistent<FunctionTemplate> ProjectionManager::s_constructorTemplate;

  v8::Local<v8::Value> WrapProjectionManager(::Windows::UI::ViewManagement::ProjectionManager^ 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>(ProjectionManager::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::ViewManagement::ProjectionManager^ UnwrapProjectionManager(Local<Value> value) {
     return ProjectionManager::Unwrap<ProjectionManager>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitProjectionManager(Local<Object> exports) {
    ProjectionManager::Init(exports);
  }

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

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


          
            Nan::SetPrototypeMethod(localRef, "showAsync", ShowAsync);
            Nan::SetPrototypeMethod(localRef, "hideAsync", HideAsync);
          

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

          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("foregroundColor").ToLocalChecked(), ForegroundColorGetter, ForegroundColorSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("backgroundOpacity").ToLocalChecked(), BackgroundOpacityGetter, BackgroundOpacitySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("backgroundColor").ToLocalChecked(), BackgroundColorGetter, BackgroundColorSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("occludedRect").ToLocalChecked(), OccludedRectGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("progressIndicator").ToLocalChecked(), ProgressIndicatorGetter);

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

        Nan::SetMethod(constructor, "getForCurrentView", GetForCurrentView);


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

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

    private:

      StatusBar(::Windows::UI::ViewManagement::StatusBar^ 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::UI::ViewManagement::StatusBar^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::StatusBar^>(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;
      }

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

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


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

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::StatusBar^>(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;
      }

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

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


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

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

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


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


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

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




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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::UI::ViewManagement::StatusBar^ result;
          result = ::Windows::UI::ViewManagement::StatusBar::GetForCurrentView();
          info.GetReturnValue().Set(WrapStatusBar(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 ForegroundColorGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::StatusBar^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->ForegroundColor;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ForegroundColorSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::StatusBar^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::StatusBar^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::StatusBar^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::StatusBar^>(info.This())) {
        return;
      }

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

      try  {
        ::Platform::IBox<::Windows::UI::Color>^ result = wrapper->_instance->BackgroundColor;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::ColorToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BackgroundColorSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::StatusBar^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<::Windows::UI::Color>^ winRtValue = ref new ::Platform::Box<::Windows::UI::Color>(NodeRT::Utils::ColorFromJs(value));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::StatusBar^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::StatusBar^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::UI::ViewManagement::StatusBarProgressIndicator^ result = wrapper->_instance->ProgressIndicator;
        info.GetReturnValue().Set(WrapStatusBarProgressIndicator(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


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

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

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

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

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"hiding", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::StatusBar^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        StatusBar *wrapper = StatusBar::Unwrap<StatusBar>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

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


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

                {
                  TryCatch tryCatch;


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


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

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

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"showing", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::StatusBar^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        StatusBar *wrapper = StatusBar::Unwrap<StatusBar>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

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


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

                {
                  TryCatch tryCatch;


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"hiding", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::StatusBar^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          StatusBar *wrapper = StatusBar::Unwrap<StatusBar>(info.This());
          wrapper->_instance->Hiding::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"showing", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::StatusBar^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          StatusBar *wrapper = StatusBar::Unwrap<StatusBar>(info.This());
          wrapper->_instance->Showing::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

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

      friend v8::Local<v8::Value> WrapStatusBar(::Windows::UI::ViewManagement::StatusBar^ wintRtInstance);
      friend ::Windows::UI::ViewManagement::StatusBar^ UnwrapStatusBar(Local<Value> value);
  };

  Persistent<FunctionTemplate> StatusBar::s_constructorTemplate;

  v8::Local<v8::Value> WrapStatusBar(::Windows::UI::ViewManagement::StatusBar^ 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>(StatusBar::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::ViewManagement::StatusBar^ UnwrapStatusBar(Local<Value> value) {
     return StatusBar::Unwrap<StatusBar>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitStatusBar(Local<Object> exports) {
    StatusBar::Init(exports);
  }

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

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


          
            Nan::SetPrototypeMethod(localRef, "showAsync", ShowAsync);
            Nan::SetPrototypeMethod(localRef, "hideAsync", HideAsync);
          


          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("text").ToLocalChecked(), TextGetter, TextSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("progressValue").ToLocalChecked(), ProgressValueGetter, ProgressValueSetter);

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



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

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

    private:

      StatusBarProgressIndicator(::Windows::UI::ViewManagement::StatusBarProgressIndicator^ 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::UI::ViewManagement::StatusBarProgressIndicator^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::StatusBarProgressIndicator^>(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;
      }

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

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


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

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::StatusBarProgressIndicator^>(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;
      }

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

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


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

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

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


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


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

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




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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::StatusBarProgressIndicator^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::StatusBarProgressIndicator^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::StatusBarProgressIndicator^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::StatusBarProgressIndicator^>(info.This())) {
        return;
      }

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

      try {

        ::Platform::IBox<double>^ winRtValue = ref new ::Platform::Box<double>(Nan::To<double>(value).FromMaybe(0.0));

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


    private:
      ::Windows::UI::ViewManagement::StatusBarProgressIndicator^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapStatusBarProgressIndicator(::Windows::UI::ViewManagement::StatusBarProgressIndicator^ wintRtInstance);
      friend ::Windows::UI::ViewManagement::StatusBarProgressIndicator^ UnwrapStatusBarProgressIndicator(Local<Value> value);
  };

  Persistent<FunctionTemplate> StatusBarProgressIndicator::s_constructorTemplate;

  v8::Local<v8::Value> WrapStatusBarProgressIndicator(::Windows::UI::ViewManagement::StatusBarProgressIndicator^ 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>(StatusBarProgressIndicator::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::ViewManagement::StatusBarProgressIndicator^ UnwrapStatusBarProgressIndicator(Local<Value> value) {
     return StatusBarProgressIndicator::Unwrap<StatusBarProgressIndicator>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitStatusBarProgressIndicator(Local<Object> exports) {
    StatusBarProgressIndicator::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "uIElementColor", UIElementColor);
            Nan::SetPrototypeMethod(localRef, "getColorValue", GetColorValue);
          


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

          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("animationsEnabled").ToLocalChecked(), AnimationsEnabledGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("caretBlinkRate").ToLocalChecked(), CaretBlinkRateGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("caretBrowsingEnabled").ToLocalChecked(), CaretBrowsingEnabledGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("caretWidth").ToLocalChecked(), CaretWidthGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("cursorSize").ToLocalChecked(), CursorSizeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("doubleClickTime").ToLocalChecked(), DoubleClickTimeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("handPreference").ToLocalChecked(), HandPreferenceGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("messageDuration").ToLocalChecked(), MessageDurationGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("mouseHoverTime").ToLocalChecked(), MouseHoverTimeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("scrollBarArrowSize").ToLocalChecked(), ScrollBarArrowSizeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("scrollBarSize").ToLocalChecked(), ScrollBarSizeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("scrollBarThumbBoxSize").ToLocalChecked(), ScrollBarThumbBoxSizeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("textScaleFactor").ToLocalChecked(), TextScaleFactorGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("advancedEffectsEnabled").ToLocalChecked(), AdvancedEffectsEnabledGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("autoHideScrollBars").ToLocalChecked(), AutoHideScrollBarsGetter);

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



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

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

    private:

      UISettings(::Windows::UI::ViewManagement::UISettings^ 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::UI::ViewManagement::UISettings^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::UI::ViewManagement::UIElementType arg0 = static_cast<::Windows::UI::ViewManagement::UIElementType>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          ::Windows::UI::Color result;
          result = wrapper->_instance->UIElementColor(arg0);
          info.GetReturnValue().Set(NodeRT::Utils::ColorToJs(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 GetColorValue(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::UI::ViewManagement::UIColorType arg0 = static_cast<::Windows::UI::ViewManagement::UIColorType>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          ::Windows::UI::Color result;
          result = wrapper->_instance->GetColorValue(arg0);
          info.GetReturnValue().Set(NodeRT::Utils::ColorToJs(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 AnimationsEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This())) {
        return;
      }

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

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


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

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

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

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

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"textScaleFactorChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UISettings *wrapper = UISettings::Unwrap<UISettings>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

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


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

                {
                  TryCatch tryCatch;


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


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

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

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"colorValuesChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UISettings *wrapper = UISettings::Unwrap<UISettings>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

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


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

                {
                  TryCatch tryCatch;


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


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

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

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"advancedEffectsEnabledChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UISettings *wrapper = UISettings::Unwrap<UISettings>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

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


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

                {
                  TryCatch tryCatch;


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


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

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

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"autoHideScrollBarsChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UISettings *wrapper = UISettings::Unwrap<UISettings>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->AutoHideScrollBarsChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::ViewManagement::UISettings^, ::Windows::UI::ViewManagement::UISettingsAutoHideScrollBarsChangedEventArgs^>(
            [callbackObjPtr](::Windows::UI::ViewManagement::UISettings^ arg0, ::Windows::UI::ViewManagement::UISettingsAutoHideScrollBarsChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUISettings(arg0);
                  wrappedArg1 = WrapUISettingsAutoHideScrollBarsChangedEventArgs(arg1);


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

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

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"animationsEnabledChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UISettings *wrapper = UISettings::Unwrap<UISettings>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->AnimationsEnabledChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::ViewManagement::UISettings^, ::Windows::UI::ViewManagement::UISettingsAnimationsEnabledChangedEventArgs^>(
            [callbackObjPtr](::Windows::UI::ViewManagement::UISettings^ arg0, ::Windows::UI::ViewManagement::UISettingsAnimationsEnabledChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUISettings(arg0);
                  wrappedArg1 = WrapUISettingsAnimationsEnabledChangedEventArgs(arg1);


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

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

      }
      else if (NodeRT::Utils::CaseInsenstiveEquals(L"messageDurationChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This()))
        {
          Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
      return;
        }
        UISettings *wrapper = UISettings::Unwrap<UISettings>(info.This());
      
        try {
          Persistent<Object>* perstPtr = new Persistent<Object>();
          perstPtr->Reset(NodeRT::Utils::CreateCallbackObjectInDomain(callback));
          std::shared_ptr<Persistent<Object>> callbackObjPtr(perstPtr,
            [] (Persistent<Object> *ptr ) {
              NodeUtils::Async::RunOnMain([ptr]() {
                ptr->Reset();
                delete ptr;
            });
          });

          registrationToken = wrapper->_instance->MessageDurationChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::UI::ViewManagement::UISettings^, ::Windows::UI::ViewManagement::UISettingsMessageDurationChangedEventArgs^>(
            [callbackObjPtr](::Windows::UI::ViewManagement::UISettings^ arg0, ::Windows::UI::ViewManagement::UISettingsMessageDurationChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapUISettings(arg0);
                  wrappedArg1 = WrapUISettingsMessageDurationChangedEventArgs(arg1);


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

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

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

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

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

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

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

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

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

      if ((!NodeRT::Utils::CaseInsenstiveEquals(L"textScaleFactorChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"colorValuesChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"advancedEffectsEnabledChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"autoHideScrollBarsChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"animationsEnabledChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"messageDurationChanged", str))) {
        Nan::ThrowError(Nan::Error(String::Concat(v8::Isolate::GetCurrent(), NodeRT::Utils::NewString(L"given event name isn't supported: "), info[0].As<String>())));
        return;
      }

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

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

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

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

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

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

      try  {
        if (NodeRT::Utils::CaseInsenstiveEquals(L"textScaleFactorChanged", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UISettings *wrapper = UISettings::Unwrap<UISettings>(info.This());
          wrapper->_instance->TextScaleFactorChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"colorValuesChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UISettings *wrapper = UISettings::Unwrap<UISettings>(info.This());
          wrapper->_instance->ColorValuesChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"advancedEffectsEnabledChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UISettings *wrapper = UISettings::Unwrap<UISettings>(info.This());
          wrapper->_instance->AdvancedEffectsEnabledChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"autoHideScrollBarsChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UISettings *wrapper = UISettings::Unwrap<UISettings>(info.This());
          wrapper->_instance->AutoHideScrollBarsChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"animationsEnabledChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UISettings *wrapper = UISettings::Unwrap<UISettings>(info.This());
          wrapper->_instance->AnimationsEnabledChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"messageDurationChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UISettings^>(info.This()))
          {
            Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"The caller of this method isn't of the expected type or internal WinRt object was disposed")));
            return;
          }
          UISettings *wrapper = UISettings::Unwrap<UISettings>(info.This());
          wrapper->_instance->MessageDurationChanged::remove(registrationToken);
        }
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }

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

      friend v8::Local<v8::Value> WrapUISettings(::Windows::UI::ViewManagement::UISettings^ wintRtInstance);
      friend ::Windows::UI::ViewManagement::UISettings^ UnwrapUISettings(Local<Value> value);
  };

  Persistent<FunctionTemplate> UISettings::s_constructorTemplate;

  v8::Local<v8::Value> WrapUISettings(::Windows::UI::ViewManagement::UISettings^ 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>(UISettings::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::ViewManagement::UISettings^ UnwrapUISettings(Local<Value> value) {
     return UISettings::Unwrap<UISettings>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitUISettings(Local<Object> exports) {
    UISettings::Init(exports);
  }

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






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



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

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

    private:

      UISettingsAnimationsEnabledChangedEventArgs(::Windows::UI::ViewManagement::UISettingsAnimationsEnabledChangedEventArgs^ 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::UI::ViewManagement::UISettingsAnimationsEnabledChangedEventArgs^ winRtInstance;


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

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

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







    private:
      ::Windows::UI::ViewManagement::UISettingsAnimationsEnabledChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapUISettingsAnimationsEnabledChangedEventArgs(::Windows::UI::ViewManagement::UISettingsAnimationsEnabledChangedEventArgs^ wintRtInstance);
      friend ::Windows::UI::ViewManagement::UISettingsAnimationsEnabledChangedEventArgs^ UnwrapUISettingsAnimationsEnabledChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> UISettingsAnimationsEnabledChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapUISettingsAnimationsEnabledChangedEventArgs(::Windows::UI::ViewManagement::UISettingsAnimationsEnabledChangedEventArgs^ 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>(UISettingsAnimationsEnabledChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::ViewManagement::UISettingsAnimationsEnabledChangedEventArgs^ UnwrapUISettingsAnimationsEnabledChangedEventArgs(Local<Value> value) {
     return UISettingsAnimationsEnabledChangedEventArgs::Unwrap<UISettingsAnimationsEnabledChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitUISettingsAnimationsEnabledChangedEventArgs(Local<Object> exports) {
    UISettingsAnimationsEnabledChangedEventArgs::Init(exports);
  }

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






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



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

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

    private:

      UISettingsAutoHideScrollBarsChangedEventArgs(::Windows::UI::ViewManagement::UISettingsAutoHideScrollBarsChangedEventArgs^ 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::UI::ViewManagement::UISettingsAutoHideScrollBarsChangedEventArgs^ winRtInstance;


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

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

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







    private:
      ::Windows::UI::ViewManagement::UISettingsAutoHideScrollBarsChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapUISettingsAutoHideScrollBarsChangedEventArgs(::Windows::UI::ViewManagement::UISettingsAutoHideScrollBarsChangedEventArgs^ wintRtInstance);
      friend ::Windows::UI::ViewManagement::UISettingsAutoHideScrollBarsChangedEventArgs^ UnwrapUISettingsAutoHideScrollBarsChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> UISettingsAutoHideScrollBarsChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapUISettingsAutoHideScrollBarsChangedEventArgs(::Windows::UI::ViewManagement::UISettingsAutoHideScrollBarsChangedEventArgs^ 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>(UISettingsAutoHideScrollBarsChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::ViewManagement::UISettingsAutoHideScrollBarsChangedEventArgs^ UnwrapUISettingsAutoHideScrollBarsChangedEventArgs(Local<Value> value) {
     return UISettingsAutoHideScrollBarsChangedEventArgs::Unwrap<UISettingsAutoHideScrollBarsChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitUISettingsAutoHideScrollBarsChangedEventArgs(Local<Object> exports) {
    UISettingsAutoHideScrollBarsChangedEventArgs::Init(exports);
  }

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






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



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

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

    private:

      UISettingsMessageDurationChangedEventArgs(::Windows::UI::ViewManagement::UISettingsMessageDurationChangedEventArgs^ 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::UI::ViewManagement::UISettingsMessageDurationChangedEventArgs^ winRtInstance;


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

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

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







    private:
      ::Windows::UI::ViewManagement::UISettingsMessageDurationChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapUISettingsMessageDurationChangedEventArgs(::Windows::UI::ViewManagement::UISettingsMessageDurationChangedEventArgs^ wintRtInstance);
      friend ::Windows::UI::ViewManagement::UISettingsMessageDurationChangedEventArgs^ UnwrapUISettingsMessageDurationChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> UISettingsMessageDurationChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapUISettingsMessageDurationChangedEventArgs(::Windows::UI::ViewManagement::UISettingsMessageDurationChangedEventArgs^ 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>(UISettingsMessageDurationChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::ViewManagement::UISettingsMessageDurationChangedEventArgs^ UnwrapUISettingsMessageDurationChangedEventArgs(Local<Value> value) {
     return UISettingsMessageDurationChangedEventArgs::Unwrap<UISettingsMessageDurationChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitUISettingsMessageDurationChangedEventArgs(Local<Object> exports) {
    UISettingsMessageDurationChangedEventArgs::Init(exports);
  }

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





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

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

        Nan::SetMethod(constructor, "getForCurrentView", GetForCurrentView);


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

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

    private:

      UIViewSettings(::Windows::UI::ViewManagement::UIViewSettings^ 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::UI::ViewManagement::UIViewSettings^ winRtInstance;


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

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

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





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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::UI::ViewManagement::UIViewSettings^ result;
          result = ::Windows::UI::ViewManagement::UIViewSettings::GetForCurrentView();
          info.GetReturnValue().Set(WrapUIViewSettings(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 UserInteractionModeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::UIViewSettings^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::UI::ViewManagement::UIViewSettings^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapUIViewSettings(::Windows::UI::ViewManagement::UIViewSettings^ wintRtInstance);
      friend ::Windows::UI::ViewManagement::UIViewSettings^ UnwrapUIViewSettings(Local<Value> value);
  };

  Persistent<FunctionTemplate> UIViewSettings::s_constructorTemplate;

  v8::Local<v8::Value> WrapUIViewSettings(::Windows::UI::ViewManagement::UIViewSettings^ 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>(UIViewSettings::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::ViewManagement::UIViewSettings^ UnwrapUIViewSettings(Local<Value> value) {
     return UIViewSettings::Unwrap<UIViewSettings>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitUIViewSettings(Local<Object> exports) {
    UIViewSettings::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("viewSizePreference").ToLocalChecked(), ViewSizePreferenceGetter, ViewSizePreferenceSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("customSize").ToLocalChecked(), CustomSizeGetter, CustomSizeSetter);

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

        Nan::SetMethod(constructor, "createDefault", CreateDefault);


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

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

    private:

      ViewModePreferences(::Windows::UI::ViewManagement::ViewModePreferences^ 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::UI::ViewManagement::ViewModePreferences^ winRtInstance;


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

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

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





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

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::UI::ViewManagement::ApplicationViewMode arg0 = static_cast<::Windows::UI::ViewManagement::ApplicationViewMode>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          ::Windows::UI::ViewManagement::ViewModePreferences^ result;
          result = ::Windows::UI::ViewManagement::ViewModePreferences::CreateDefault(arg0);
          info.GetReturnValue().Set(WrapViewModePreferences(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 ViewSizePreferenceGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ViewModePreferences^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ViewModePreferences^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::UI::ViewManagement::ViewModePreferences^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Foundation::Size winRtValue = NodeRT::Utils::SizeFromJs(value);

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


    private:
      ::Windows::UI::ViewManagement::ViewModePreferences^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapViewModePreferences(::Windows::UI::ViewManagement::ViewModePreferences^ wintRtInstance);
      friend ::Windows::UI::ViewManagement::ViewModePreferences^ UnwrapViewModePreferences(Local<Value> value);
  };

  Persistent<FunctionTemplate> ViewModePreferences::s_constructorTemplate;

  v8::Local<v8::Value> WrapViewModePreferences(::Windows::UI::ViewManagement::ViewModePreferences^ 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>(ViewModePreferences::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::UI::ViewManagement::ViewModePreferences^ UnwrapViewModePreferences(Local<Value> value) {
     return ViewModePreferences::Unwrap<ViewModePreferences>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitViewModePreferences(Local<Object> exports) {
    ViewModePreferences::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::UI::ViewManagement::InitApplicationViewBoundsModeEnum(target);
      NodeRT::Windows::UI::ViewManagement::InitApplicationViewModeEnum(target);
      NodeRT::Windows::UI::ViewManagement::InitApplicationViewOrientationEnum(target);
      NodeRT::Windows::UI::ViewManagement::InitApplicationViewStateEnum(target);
      NodeRT::Windows::UI::ViewManagement::InitApplicationViewSwitchingOptionsEnum(target);
      NodeRT::Windows::UI::ViewManagement::InitApplicationViewWindowingModeEnum(target);
      NodeRT::Windows::UI::ViewManagement::InitFullScreenSystemOverlayModeEnum(target);
      NodeRT::Windows::UI::ViewManagement::InitHandPreferenceEnum(target);
      NodeRT::Windows::UI::ViewManagement::InitUIColorTypeEnum(target);
      NodeRT::Windows::UI::ViewManagement::InitUIElementTypeEnum(target);
      NodeRT::Windows::UI::ViewManagement::InitUserInteractionModeEnum(target);
      NodeRT::Windows::UI::ViewManagement::InitViewSizePreferenceEnum(target);
      NodeRT::Windows::UI::ViewManagement::InitAccessibilitySettings(target);
      NodeRT::Windows::UI::ViewManagement::InitActivationViewSwitcher(target);
      NodeRT::Windows::UI::ViewManagement::InitApplicationView(target);
      NodeRT::Windows::UI::ViewManagement::InitApplicationViewConsolidatedEventArgs(target);
      NodeRT::Windows::UI::ViewManagement::InitApplicationViewScaling(target);
      NodeRT::Windows::UI::ViewManagement::InitApplicationViewSwitcher(target);
      NodeRT::Windows::UI::ViewManagement::InitApplicationViewTitleBar(target);
      NodeRT::Windows::UI::ViewManagement::InitApplicationViewTransferContext(target);
      NodeRT::Windows::UI::ViewManagement::InitInputPane(target);
      NodeRT::Windows::UI::ViewManagement::InitInputPaneVisibilityEventArgs(target);
      NodeRT::Windows::UI::ViewManagement::InitProjectionManager(target);
      NodeRT::Windows::UI::ViewManagement::InitStatusBar(target);
      NodeRT::Windows::UI::ViewManagement::InitStatusBarProgressIndicator(target);
      NodeRT::Windows::UI::ViewManagement::InitUISettings(target);
      NodeRT::Windows::UI::ViewManagement::InitUISettingsAnimationsEnabledChangedEventArgs(target);
      NodeRT::Windows::UI::ViewManagement::InitUISettingsAutoHideScrollBarsChangedEventArgs(target);
      NodeRT::Windows::UI::ViewManagement::InitUISettingsMessageDurationChangedEventArgs(target);
      NodeRT::Windows::UI::ViewManagement::InitUIViewSettings(target);
      NodeRT::Windows::UI::ViewManagement::InitViewModePreferences(target);


  NodeRT::Utils::RegisterNameSpace("Windows.UI.ViewManagement", target);
}



NODE_MODULE(binding, init)