// 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 Graphics { namespace Printing { 
  v8::Local<v8::Value> WrapIPrintDocumentSource(::Windows::Graphics::Printing::IPrintDocumentSource^ wintRtInstance);
  ::Windows::Graphics::Printing::IPrintDocumentSource^ UnwrapIPrintDocumentSource(Local<Value> value);
  
  v8::Local<v8::Value> WrapIPrintTaskOptionsCore(::Windows::Graphics::Printing::IPrintTaskOptionsCore^ wintRtInstance);
  ::Windows::Graphics::Printing::IPrintTaskOptionsCore^ UnwrapIPrintTaskOptionsCore(Local<Value> value);
  
  v8::Local<v8::Value> WrapIPrintTaskOptionsCoreProperties(::Windows::Graphics::Printing::IPrintTaskOptionsCoreProperties^ wintRtInstance);
  ::Windows::Graphics::Printing::IPrintTaskOptionsCoreProperties^ UnwrapIPrintTaskOptionsCoreProperties(Local<Value> value);
  
  v8::Local<v8::Value> WrapIPrintTaskOptionsCoreUIConfiguration(::Windows::Graphics::Printing::IPrintTaskOptionsCoreUIConfiguration^ wintRtInstance);
  ::Windows::Graphics::Printing::IPrintTaskOptionsCoreUIConfiguration^ UnwrapIPrintTaskOptionsCoreUIConfiguration(Local<Value> value);
  
  v8::Local<v8::Value> WrapPrintManager(::Windows::Graphics::Printing::PrintManager^ wintRtInstance);
  ::Windows::Graphics::Printing::PrintManager^ UnwrapPrintManager(Local<Value> value);
  
  v8::Local<v8::Value> WrapPrintPageInfo(::Windows::Graphics::Printing::PrintPageInfo^ wintRtInstance);
  ::Windows::Graphics::Printing::PrintPageInfo^ UnwrapPrintPageInfo(Local<Value> value);
  
  v8::Local<v8::Value> WrapPrintPageRange(::Windows::Graphics::Printing::PrintPageRange^ wintRtInstance);
  ::Windows::Graphics::Printing::PrintPageRange^ UnwrapPrintPageRange(Local<Value> value);
  
  v8::Local<v8::Value> WrapPrintPageRangeOptions(::Windows::Graphics::Printing::PrintPageRangeOptions^ wintRtInstance);
  ::Windows::Graphics::Printing::PrintPageRangeOptions^ UnwrapPrintPageRangeOptions(Local<Value> value);
  
  v8::Local<v8::Value> WrapPrintTask(::Windows::Graphics::Printing::PrintTask^ wintRtInstance);
  ::Windows::Graphics::Printing::PrintTask^ UnwrapPrintTask(Local<Value> value);
  
  v8::Local<v8::Value> WrapPrintTaskCompletedEventArgs(::Windows::Graphics::Printing::PrintTaskCompletedEventArgs^ wintRtInstance);
  ::Windows::Graphics::Printing::PrintTaskCompletedEventArgs^ UnwrapPrintTaskCompletedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapPrintTaskOptions(::Windows::Graphics::Printing::PrintTaskOptions^ wintRtInstance);
  ::Windows::Graphics::Printing::PrintTaskOptions^ UnwrapPrintTaskOptions(Local<Value> value);
  
  v8::Local<v8::Value> WrapPrintTaskProgressingEventArgs(::Windows::Graphics::Printing::PrintTaskProgressingEventArgs^ wintRtInstance);
  ::Windows::Graphics::Printing::PrintTaskProgressingEventArgs^ UnwrapPrintTaskProgressingEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapPrintTaskRequest(::Windows::Graphics::Printing::PrintTaskRequest^ wintRtInstance);
  ::Windows::Graphics::Printing::PrintTaskRequest^ UnwrapPrintTaskRequest(Local<Value> value);
  
  v8::Local<v8::Value> WrapPrintTaskRequestedDeferral(::Windows::Graphics::Printing::PrintTaskRequestedDeferral^ wintRtInstance);
  ::Windows::Graphics::Printing::PrintTaskRequestedDeferral^ UnwrapPrintTaskRequestedDeferral(Local<Value> value);
  
  v8::Local<v8::Value> WrapPrintTaskRequestedEventArgs(::Windows::Graphics::Printing::PrintTaskRequestedEventArgs^ wintRtInstance);
  ::Windows::Graphics::Printing::PrintTaskRequestedEventArgs^ UnwrapPrintTaskRequestedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapPrintTaskSourceRequestedArgs(::Windows::Graphics::Printing::PrintTaskSourceRequestedArgs^ wintRtInstance);
  ::Windows::Graphics::Printing::PrintTaskSourceRequestedArgs^ UnwrapPrintTaskSourceRequestedArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapPrintTaskSourceRequestedDeferral(::Windows::Graphics::Printing::PrintTaskSourceRequestedDeferral^ wintRtInstance);
  ::Windows::Graphics::Printing::PrintTaskSourceRequestedDeferral^ UnwrapPrintTaskSourceRequestedDeferral(Local<Value> value);
  
  v8::Local<v8::Value> WrapStandardPrintTaskOptions(::Windows::Graphics::Printing::StandardPrintTaskOptions^ wintRtInstance);
  ::Windows::Graphics::Printing::StandardPrintTaskOptions^ UnwrapStandardPrintTaskOptions(Local<Value> value);
  



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

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

    Nan::Set(exports, Nan::New<String>("PrintBinding").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("default").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintBinding::Default)));
    Nan::Set(enumObject, Nan::New<String>("notAvailable").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintBinding::NotAvailable)));
    Nan::Set(enumObject, Nan::New<String>("printerCustom").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintBinding::PrinterCustom)));
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintBinding::None)));
    Nan::Set(enumObject, Nan::New<String>("bale").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintBinding::Bale)));
    Nan::Set(enumObject, Nan::New<String>("bindBottom").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintBinding::BindBottom)));
    Nan::Set(enumObject, Nan::New<String>("bindLeft").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintBinding::BindLeft)));
    Nan::Set(enumObject, Nan::New<String>("bindRight").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintBinding::BindRight)));
    Nan::Set(enumObject, Nan::New<String>("bindTop").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintBinding::BindTop)));
    Nan::Set(enumObject, Nan::New<String>("booklet").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintBinding::Booklet)));
    Nan::Set(enumObject, Nan::New<String>("edgeStitchBottom").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintBinding::EdgeStitchBottom)));
    Nan::Set(enumObject, Nan::New<String>("edgeStitchLeft").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintBinding::EdgeStitchLeft)));
    Nan::Set(enumObject, Nan::New<String>("edgeStitchRight").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintBinding::EdgeStitchRight)));
    Nan::Set(enumObject, Nan::New<String>("edgeStitchTop").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintBinding::EdgeStitchTop)));
    Nan::Set(enumObject, Nan::New<String>("fold").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintBinding::Fold)));
    Nan::Set(enumObject, Nan::New<String>("jogOffset").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintBinding::JogOffset)));
    Nan::Set(enumObject, Nan::New<String>("trim").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintBinding::Trim)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("PrintBordering").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("default").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintBordering::Default)));
    Nan::Set(enumObject, Nan::New<String>("notAvailable").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintBordering::NotAvailable)));
    Nan::Set(enumObject, Nan::New<String>("printerCustom").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintBordering::PrinterCustom)));
    Nan::Set(enumObject, Nan::New<String>("bordered").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintBordering::Bordered)));
    Nan::Set(enumObject, Nan::New<String>("borderless").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintBordering::Borderless)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("PrintCollation").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("default").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintCollation::Default)));
    Nan::Set(enumObject, Nan::New<String>("notAvailable").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintCollation::NotAvailable)));
    Nan::Set(enumObject, Nan::New<String>("printerCustom").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintCollation::PrinterCustom)));
    Nan::Set(enumObject, Nan::New<String>("collated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintCollation::Collated)));
    Nan::Set(enumObject, Nan::New<String>("uncollated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintCollation::Uncollated)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("PrintColorMode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("default").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintColorMode::Default)));
    Nan::Set(enumObject, Nan::New<String>("notAvailable").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintColorMode::NotAvailable)));
    Nan::Set(enumObject, Nan::New<String>("printerCustom").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintColorMode::PrinterCustom)));
    Nan::Set(enumObject, Nan::New<String>("color").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintColorMode::Color)));
    Nan::Set(enumObject, Nan::New<String>("grayscale").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintColorMode::Grayscale)));
    Nan::Set(enumObject, Nan::New<String>("monochrome").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintColorMode::Monochrome)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("PrintDuplex").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("default").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintDuplex::Default)));
    Nan::Set(enumObject, Nan::New<String>("notAvailable").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintDuplex::NotAvailable)));
    Nan::Set(enumObject, Nan::New<String>("printerCustom").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintDuplex::PrinterCustom)));
    Nan::Set(enumObject, Nan::New<String>("oneSided").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintDuplex::OneSided)));
    Nan::Set(enumObject, Nan::New<String>("twoSidedShortEdge").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintDuplex::TwoSidedShortEdge)));
    Nan::Set(enumObject, Nan::New<String>("twoSidedLongEdge").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintDuplex::TwoSidedLongEdge)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("PrintHolePunch").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("default").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintHolePunch::Default)));
    Nan::Set(enumObject, Nan::New<String>("notAvailable").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintHolePunch::NotAvailable)));
    Nan::Set(enumObject, Nan::New<String>("printerCustom").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintHolePunch::PrinterCustom)));
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintHolePunch::None)));
    Nan::Set(enumObject, Nan::New<String>("leftEdge").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintHolePunch::LeftEdge)));
    Nan::Set(enumObject, Nan::New<String>("rightEdge").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintHolePunch::RightEdge)));
    Nan::Set(enumObject, Nan::New<String>("topEdge").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintHolePunch::TopEdge)));
    Nan::Set(enumObject, Nan::New<String>("bottomEdge").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintHolePunch::BottomEdge)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("PrintMediaSize").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("default").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Default)));
    Nan::Set(enumObject, Nan::New<String>("notAvailable").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NotAvailable)));
    Nan::Set(enumObject, Nan::New<String>("printerCustom").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::PrinterCustom)));
    Nan::Set(enumObject, Nan::New<String>("businessCard").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::BusinessCard)));
    Nan::Set(enumObject, Nan::New<String>("creditCard").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::CreditCard)));
    Nan::Set(enumObject, Nan::New<String>("isoA0").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoA0)));
    Nan::Set(enumObject, Nan::New<String>("isoA1").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoA1)));
    Nan::Set(enumObject, Nan::New<String>("isoA10").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoA10)));
    Nan::Set(enumObject, Nan::New<String>("isoA2").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoA2)));
    Nan::Set(enumObject, Nan::New<String>("isoA3").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoA3)));
    Nan::Set(enumObject, Nan::New<String>("isoA3Extra").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoA3Extra)));
    Nan::Set(enumObject, Nan::New<String>("isoA3Rotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoA3Rotated)));
    Nan::Set(enumObject, Nan::New<String>("isoA4").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoA4)));
    Nan::Set(enumObject, Nan::New<String>("isoA4Extra").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoA4Extra)));
    Nan::Set(enumObject, Nan::New<String>("isoA4Rotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoA4Rotated)));
    Nan::Set(enumObject, Nan::New<String>("isoA5").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoA5)));
    Nan::Set(enumObject, Nan::New<String>("isoA5Extra").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoA5Extra)));
    Nan::Set(enumObject, Nan::New<String>("isoA5Rotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoA5Rotated)));
    Nan::Set(enumObject, Nan::New<String>("isoA6").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoA6)));
    Nan::Set(enumObject, Nan::New<String>("isoA6Rotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoA6Rotated)));
    Nan::Set(enumObject, Nan::New<String>("isoA7").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoA7)));
    Nan::Set(enumObject, Nan::New<String>("isoA8").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoA8)));
    Nan::Set(enumObject, Nan::New<String>("isoA9").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoA9)));
    Nan::Set(enumObject, Nan::New<String>("isoB0").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoB0)));
    Nan::Set(enumObject, Nan::New<String>("isoB1").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoB1)));
    Nan::Set(enumObject, Nan::New<String>("isoB10").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoB10)));
    Nan::Set(enumObject, Nan::New<String>("isoB2").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoB2)));
    Nan::Set(enumObject, Nan::New<String>("isoB3").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoB3)));
    Nan::Set(enumObject, Nan::New<String>("isoB4").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoB4)));
    Nan::Set(enumObject, Nan::New<String>("isoB4Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoB4Envelope)));
    Nan::Set(enumObject, Nan::New<String>("isoB5Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoB5Envelope)));
    Nan::Set(enumObject, Nan::New<String>("isoB5Extra").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoB5Extra)));
    Nan::Set(enumObject, Nan::New<String>("isoB7").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoB7)));
    Nan::Set(enumObject, Nan::New<String>("isoB8").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoB8)));
    Nan::Set(enumObject, Nan::New<String>("isoB9").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoB9)));
    Nan::Set(enumObject, Nan::New<String>("isoC0").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoC0)));
    Nan::Set(enumObject, Nan::New<String>("isoC1").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoC1)));
    Nan::Set(enumObject, Nan::New<String>("isoC10").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoC10)));
    Nan::Set(enumObject, Nan::New<String>("isoC2").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoC2)));
    Nan::Set(enumObject, Nan::New<String>("isoC3").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoC3)));
    Nan::Set(enumObject, Nan::New<String>("isoC3Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoC3Envelope)));
    Nan::Set(enumObject, Nan::New<String>("isoC4").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoC4)));
    Nan::Set(enumObject, Nan::New<String>("isoC4Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoC4Envelope)));
    Nan::Set(enumObject, Nan::New<String>("isoC5").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoC5)));
    Nan::Set(enumObject, Nan::New<String>("isoC5Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoC5Envelope)));
    Nan::Set(enumObject, Nan::New<String>("isoC6").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoC6)));
    Nan::Set(enumObject, Nan::New<String>("isoC6C5Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoC6C5Envelope)));
    Nan::Set(enumObject, Nan::New<String>("isoC6Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoC6Envelope)));
    Nan::Set(enumObject, Nan::New<String>("isoC7").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoC7)));
    Nan::Set(enumObject, Nan::New<String>("isoC8").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoC8)));
    Nan::Set(enumObject, Nan::New<String>("isoC9").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoC9)));
    Nan::Set(enumObject, Nan::New<String>("isoDLEnvelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoDLEnvelope)));
    Nan::Set(enumObject, Nan::New<String>("isoDLEnvelopeRotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoDLEnvelopeRotated)));
    Nan::Set(enumObject, Nan::New<String>("isoSRA3").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::IsoSRA3)));
    Nan::Set(enumObject, Nan::New<String>("japan2LPhoto").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Japan2LPhoto)));
    Nan::Set(enumObject, Nan::New<String>("japanChou3Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JapanChou3Envelope)));
    Nan::Set(enumObject, Nan::New<String>("japanChou3EnvelopeRotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JapanChou3EnvelopeRotated)));
    Nan::Set(enumObject, Nan::New<String>("japanChou4Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JapanChou4Envelope)));
    Nan::Set(enumObject, Nan::New<String>("japanChou4EnvelopeRotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JapanChou4EnvelopeRotated)));
    Nan::Set(enumObject, Nan::New<String>("japanDoubleHagakiPostcard").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JapanDoubleHagakiPostcard)));
    Nan::Set(enumObject, Nan::New<String>("japanDoubleHagakiPostcardRotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JapanDoubleHagakiPostcardRotated)));
    Nan::Set(enumObject, Nan::New<String>("japanHagakiPostcard").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JapanHagakiPostcard)));
    Nan::Set(enumObject, Nan::New<String>("japanHagakiPostcardRotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JapanHagakiPostcardRotated)));
    Nan::Set(enumObject, Nan::New<String>("japanKaku2Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JapanKaku2Envelope)));
    Nan::Set(enumObject, Nan::New<String>("japanKaku2EnvelopeRotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JapanKaku2EnvelopeRotated)));
    Nan::Set(enumObject, Nan::New<String>("japanKaku3Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JapanKaku3Envelope)));
    Nan::Set(enumObject, Nan::New<String>("japanKaku3EnvelopeRotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JapanKaku3EnvelopeRotated)));
    Nan::Set(enumObject, Nan::New<String>("japanLPhoto").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JapanLPhoto)));
    Nan::Set(enumObject, Nan::New<String>("japanQuadrupleHagakiPostcard").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JapanQuadrupleHagakiPostcard)));
    Nan::Set(enumObject, Nan::New<String>("japanYou1Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JapanYou1Envelope)));
    Nan::Set(enumObject, Nan::New<String>("japanYou2Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JapanYou2Envelope)));
    Nan::Set(enumObject, Nan::New<String>("japanYou3Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JapanYou3Envelope)));
    Nan::Set(enumObject, Nan::New<String>("japanYou4Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JapanYou4Envelope)));
    Nan::Set(enumObject, Nan::New<String>("japanYou4EnvelopeRotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JapanYou4EnvelopeRotated)));
    Nan::Set(enumObject, Nan::New<String>("japanYou6Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JapanYou6Envelope)));
    Nan::Set(enumObject, Nan::New<String>("japanYou6EnvelopeRotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JapanYou6EnvelopeRotated)));
    Nan::Set(enumObject, Nan::New<String>("jisB0").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JisB0)));
    Nan::Set(enumObject, Nan::New<String>("jisB1").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JisB1)));
    Nan::Set(enumObject, Nan::New<String>("jisB10").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JisB10)));
    Nan::Set(enumObject, Nan::New<String>("jisB2").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JisB2)));
    Nan::Set(enumObject, Nan::New<String>("jisB3").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JisB3)));
    Nan::Set(enumObject, Nan::New<String>("jisB4").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JisB4)));
    Nan::Set(enumObject, Nan::New<String>("jisB4Rotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JisB4Rotated)));
    Nan::Set(enumObject, Nan::New<String>("jisB5").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JisB5)));
    Nan::Set(enumObject, Nan::New<String>("jisB5Rotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JisB5Rotated)));
    Nan::Set(enumObject, Nan::New<String>("jisB6").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JisB6)));
    Nan::Set(enumObject, Nan::New<String>("jisB6Rotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JisB6Rotated)));
    Nan::Set(enumObject, Nan::New<String>("jisB7").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JisB7)));
    Nan::Set(enumObject, Nan::New<String>("jisB8").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JisB8)));
    Nan::Set(enumObject, Nan::New<String>("jisB9").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::JisB9)));
    Nan::Set(enumObject, Nan::New<String>("northAmerica10x11").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmerica10x11)));
    Nan::Set(enumObject, Nan::New<String>("northAmerica10x12").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmerica10x12)));
    Nan::Set(enumObject, Nan::New<String>("northAmerica10x14").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmerica10x14)));
    Nan::Set(enumObject, Nan::New<String>("northAmerica11x17").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmerica11x17)));
    Nan::Set(enumObject, Nan::New<String>("northAmerica14x17").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmerica14x17)));
    Nan::Set(enumObject, Nan::New<String>("northAmerica4x6").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmerica4x6)));
    Nan::Set(enumObject, Nan::New<String>("northAmerica4x8").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmerica4x8)));
    Nan::Set(enumObject, Nan::New<String>("northAmerica5x7").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmerica5x7)));
    Nan::Set(enumObject, Nan::New<String>("northAmerica8x10").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmerica8x10)));
    Nan::Set(enumObject, Nan::New<String>("northAmerica9x11").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmerica9x11)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaArchitectureASheet").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaArchitectureASheet)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaArchitectureBSheet").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaArchitectureBSheet)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaArchitectureCSheet").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaArchitectureCSheet)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaArchitectureDSheet").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaArchitectureDSheet)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaArchitectureESheet").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaArchitectureESheet)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaCSheet").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaCSheet)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaDSheet").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaDSheet)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaESheet").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaESheet)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaExecutive").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaExecutive)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaGermanLegalFanfold").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaGermanLegalFanfold)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaGermanStandardFanfold").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaGermanStandardFanfold)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaLegal").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaLegal)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaLegalExtra").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaLegalExtra)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaLetter").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaLetter)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaLetterExtra").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaLetterExtra)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaLetterPlus").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaLetterPlus)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaLetterRotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaLetterRotated)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaMonarchEnvelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaMonarchEnvelope)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaNote").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaNote)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaNumber10Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaNumber10Envelope)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaNumber10EnvelopeRotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaNumber10EnvelopeRotated)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaNumber11Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaNumber11Envelope)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaNumber12Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaNumber12Envelope)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaNumber14Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaNumber14Envelope)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaNumber9Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaNumber9Envelope)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaPersonalEnvelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaPersonalEnvelope)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaQuarto").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaQuarto)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaStatement").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaStatement)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaSuperA").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaSuperA)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaSuperB").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaSuperB)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaTabloid").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaTabloid)));
    Nan::Set(enumObject, Nan::New<String>("northAmericaTabloidExtra").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::NorthAmericaTabloidExtra)));
    Nan::Set(enumObject, Nan::New<String>("otherMetricA3Plus").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::OtherMetricA3Plus)));
    Nan::Set(enumObject, Nan::New<String>("otherMetricA4Plus").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::OtherMetricA4Plus)));
    Nan::Set(enumObject, Nan::New<String>("otherMetricFolio").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::OtherMetricFolio)));
    Nan::Set(enumObject, Nan::New<String>("otherMetricInviteEnvelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::OtherMetricInviteEnvelope)));
    Nan::Set(enumObject, Nan::New<String>("otherMetricItalianEnvelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::OtherMetricItalianEnvelope)));
    Nan::Set(enumObject, Nan::New<String>("prc10Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Prc10Envelope)));
    Nan::Set(enumObject, Nan::New<String>("prc10EnvelopeRotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Prc10EnvelopeRotated)));
    Nan::Set(enumObject, Nan::New<String>("prc16K").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Prc16K)));
    Nan::Set(enumObject, Nan::New<String>("prc16KRotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Prc16KRotated)));
    Nan::Set(enumObject, Nan::New<String>("prc1Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Prc1Envelope)));
    Nan::Set(enumObject, Nan::New<String>("prc1EnvelopeRotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Prc1EnvelopeRotated)));
    Nan::Set(enumObject, Nan::New<String>("prc2Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Prc2Envelope)));
    Nan::Set(enumObject, Nan::New<String>("prc2EnvelopeRotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Prc2EnvelopeRotated)));
    Nan::Set(enumObject, Nan::New<String>("prc32K").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Prc32K)));
    Nan::Set(enumObject, Nan::New<String>("prc32KBig").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Prc32KBig)));
    Nan::Set(enumObject, Nan::New<String>("prc32KRotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Prc32KRotated)));
    Nan::Set(enumObject, Nan::New<String>("prc3Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Prc3Envelope)));
    Nan::Set(enumObject, Nan::New<String>("prc3EnvelopeRotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Prc3EnvelopeRotated)));
    Nan::Set(enumObject, Nan::New<String>("prc4Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Prc4Envelope)));
    Nan::Set(enumObject, Nan::New<String>("prc4EnvelopeRotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Prc4EnvelopeRotated)));
    Nan::Set(enumObject, Nan::New<String>("prc5Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Prc5Envelope)));
    Nan::Set(enumObject, Nan::New<String>("prc5EnvelopeRotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Prc5EnvelopeRotated)));
    Nan::Set(enumObject, Nan::New<String>("prc6Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Prc6Envelope)));
    Nan::Set(enumObject, Nan::New<String>("prc6EnvelopeRotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Prc6EnvelopeRotated)));
    Nan::Set(enumObject, Nan::New<String>("prc7Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Prc7Envelope)));
    Nan::Set(enumObject, Nan::New<String>("prc7EnvelopeRotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Prc7EnvelopeRotated)));
    Nan::Set(enumObject, Nan::New<String>("prc8Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Prc8Envelope)));
    Nan::Set(enumObject, Nan::New<String>("prc8EnvelopeRotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Prc8EnvelopeRotated)));
    Nan::Set(enumObject, Nan::New<String>("prc9Envelope").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Prc9Envelope)));
    Nan::Set(enumObject, Nan::New<String>("prc9EnvelopeRotated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Prc9EnvelopeRotated)));
    Nan::Set(enumObject, Nan::New<String>("roll04Inch").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Roll04Inch)));
    Nan::Set(enumObject, Nan::New<String>("roll06Inch").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Roll06Inch)));
    Nan::Set(enumObject, Nan::New<String>("roll08Inch").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Roll08Inch)));
    Nan::Set(enumObject, Nan::New<String>("roll12Inch").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Roll12Inch)));
    Nan::Set(enumObject, Nan::New<String>("roll15Inch").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Roll15Inch)));
    Nan::Set(enumObject, Nan::New<String>("roll18Inch").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Roll18Inch)));
    Nan::Set(enumObject, Nan::New<String>("roll22Inch").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Roll22Inch)));
    Nan::Set(enumObject, Nan::New<String>("roll24Inch").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Roll24Inch)));
    Nan::Set(enumObject, Nan::New<String>("roll30Inch").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Roll30Inch)));
    Nan::Set(enumObject, Nan::New<String>("roll36Inch").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Roll36Inch)));
    Nan::Set(enumObject, Nan::New<String>("roll54Inch").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaSize::Roll54Inch)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("PrintMediaType").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("default").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::Default)));
    Nan::Set(enumObject, Nan::New<String>("notAvailable").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::NotAvailable)));
    Nan::Set(enumObject, Nan::New<String>("printerCustom").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::PrinterCustom)));
    Nan::Set(enumObject, Nan::New<String>("autoSelect").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::AutoSelect)));
    Nan::Set(enumObject, Nan::New<String>("archival").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::Archival)));
    Nan::Set(enumObject, Nan::New<String>("backPrintFilm").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::BackPrintFilm)));
    Nan::Set(enumObject, Nan::New<String>("bond").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::Bond)));
    Nan::Set(enumObject, Nan::New<String>("cardStock").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::CardStock)));
    Nan::Set(enumObject, Nan::New<String>("continuous").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::Continuous)));
    Nan::Set(enumObject, Nan::New<String>("envelopePlain").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::EnvelopePlain)));
    Nan::Set(enumObject, Nan::New<String>("envelopeWindow").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::EnvelopeWindow)));
    Nan::Set(enumObject, Nan::New<String>("fabric").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::Fabric)));
    Nan::Set(enumObject, Nan::New<String>("highResolution").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::HighResolution)));
    Nan::Set(enumObject, Nan::New<String>("label").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::Label)));
    Nan::Set(enumObject, Nan::New<String>("multiLayerForm").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::MultiLayerForm)));
    Nan::Set(enumObject, Nan::New<String>("multiPartForm").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::MultiPartForm)));
    Nan::Set(enumObject, Nan::New<String>("photographic").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::Photographic)));
    Nan::Set(enumObject, Nan::New<String>("photographicFilm").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::PhotographicFilm)));
    Nan::Set(enumObject, Nan::New<String>("photographicGlossy").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::PhotographicGlossy)));
    Nan::Set(enumObject, Nan::New<String>("photographicHighGloss").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::PhotographicHighGloss)));
    Nan::Set(enumObject, Nan::New<String>("photographicMatte").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::PhotographicMatte)));
    Nan::Set(enumObject, Nan::New<String>("photographicSatin").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::PhotographicSatin)));
    Nan::Set(enumObject, Nan::New<String>("photographicSemiGloss").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::PhotographicSemiGloss)));
    Nan::Set(enumObject, Nan::New<String>("plain").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::Plain)));
    Nan::Set(enumObject, Nan::New<String>("screen").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::Screen)));
    Nan::Set(enumObject, Nan::New<String>("screenPaged").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::ScreenPaged)));
    Nan::Set(enumObject, Nan::New<String>("stationery").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::Stationery)));
    Nan::Set(enumObject, Nan::New<String>("tabStockFull").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::TabStockFull)));
    Nan::Set(enumObject, Nan::New<String>("tabStockPreCut").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::TabStockPreCut)));
    Nan::Set(enumObject, Nan::New<String>("transparency").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::Transparency)));
    Nan::Set(enumObject, Nan::New<String>("tShirtTransfer").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::TShirtTransfer)));
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintMediaType::None)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("PrintOrientation").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("default").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintOrientation::Default)));
    Nan::Set(enumObject, Nan::New<String>("notAvailable").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintOrientation::NotAvailable)));
    Nan::Set(enumObject, Nan::New<String>("printerCustom").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintOrientation::PrinterCustom)));
    Nan::Set(enumObject, Nan::New<String>("portrait").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintOrientation::Portrait)));
    Nan::Set(enumObject, Nan::New<String>("portraitFlipped").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintOrientation::PortraitFlipped)));
    Nan::Set(enumObject, Nan::New<String>("landscape").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintOrientation::Landscape)));
    Nan::Set(enumObject, Nan::New<String>("landscapeFlipped").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintOrientation::LandscapeFlipped)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("PrintQuality").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("default").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintQuality::Default)));
    Nan::Set(enumObject, Nan::New<String>("notAvailable").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintQuality::NotAvailable)));
    Nan::Set(enumObject, Nan::New<String>("printerCustom").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintQuality::PrinterCustom)));
    Nan::Set(enumObject, Nan::New<String>("automatic").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintQuality::Automatic)));
    Nan::Set(enumObject, Nan::New<String>("draft").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintQuality::Draft)));
    Nan::Set(enumObject, Nan::New<String>("fax").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintQuality::Fax)));
    Nan::Set(enumObject, Nan::New<String>("high").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintQuality::High)));
    Nan::Set(enumObject, Nan::New<String>("normal").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintQuality::Normal)));
    Nan::Set(enumObject, Nan::New<String>("photographic").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintQuality::Photographic)));
    Nan::Set(enumObject, Nan::New<String>("text").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintQuality::Text)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("PrintStaple").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("default").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintStaple::Default)));
    Nan::Set(enumObject, Nan::New<String>("notAvailable").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintStaple::NotAvailable)));
    Nan::Set(enumObject, Nan::New<String>("printerCustom").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintStaple::PrinterCustom)));
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintStaple::None)));
    Nan::Set(enumObject, Nan::New<String>("stapleTopLeft").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintStaple::StapleTopLeft)));
    Nan::Set(enumObject, Nan::New<String>("stapleTopRight").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintStaple::StapleTopRight)));
    Nan::Set(enumObject, Nan::New<String>("stapleBottomLeft").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintStaple::StapleBottomLeft)));
    Nan::Set(enumObject, Nan::New<String>("stapleBottomRight").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintStaple::StapleBottomRight)));
    Nan::Set(enumObject, Nan::New<String>("stapleDualLeft").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintStaple::StapleDualLeft)));
    Nan::Set(enumObject, Nan::New<String>("stapleDualRight").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintStaple::StapleDualRight)));
    Nan::Set(enumObject, Nan::New<String>("stapleDualTop").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintStaple::StapleDualTop)));
    Nan::Set(enumObject, Nan::New<String>("stapleDualBottom").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintStaple::StapleDualBottom)));
    Nan::Set(enumObject, Nan::New<String>("saddleStitch").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintStaple::SaddleStitch)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("PrintTaskCompletion").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("abandoned").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintTaskCompletion::Abandoned)));
    Nan::Set(enumObject, Nan::New<String>("canceled").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintTaskCompletion::Canceled)));
    Nan::Set(enumObject, Nan::New<String>("failed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintTaskCompletion::Failed)));
    Nan::Set(enumObject, Nan::New<String>("submitted").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Graphics::Printing::PrintTaskCompletion::Submitted)));
  }

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

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

    symbol = Nan::New<String>("pageSize").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!NodeRT::Utils::IsSize(Nan::Get(obj,symbol).ToLocalChecked())) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("imageableRect").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!NodeRT::Utils::IsRect(Nan::Get(obj,symbol).ToLocalChecked())) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("dpiX").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsUint32()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("dpiY").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsUint32()) {
        return false;
      }
    }
    
    return true;
  }

  ::Windows::Graphics::Printing::PrintPageDescription PrintPageDescriptionFromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::Graphics::Printing::PrintPageDescription returnValue;

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

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

    symbol = Nan::New<String>("pageSize").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.PageSize = NodeRT::Utils::SizeFromJs(Nan::Get(obj,symbol).ToLocalChecked());
    }
    
    symbol = Nan::New<String>("imageableRect").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.ImageableRect = NodeRT::Utils::RectFromJs(Nan::Get(obj,symbol).ToLocalChecked());
    }
    
    symbol = Nan::New<String>("dpiX").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.DpiX = static_cast<unsigned int>(Nan::To<uint32_t>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0));
    }
    
    symbol = Nan::New<String>("dpiY").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.DpiY = static_cast<unsigned int>(Nan::To<uint32_t>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0));
    }
    
    return returnValue;
  }

  Local<Value> PrintPageDescriptionToJsObject(::Windows::Graphics::Printing::PrintPageDescription value) {
    EscapableHandleScope scope;

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

    Nan::Set(obj, Nan::New<String>("pageSize").ToLocalChecked(), NodeRT::Utils::SizeToJs(value.PageSize));
    Nan::Set(obj, Nan::New<String>("imageableRect").ToLocalChecked(), NodeRT::Utils::RectToJs(value.ImageableRect));
    Nan::Set(obj, Nan::New<String>("dpiX").ToLocalChecked(), Nan::New<Integer>(value.DpiX));
    Nan::Set(obj, Nan::New<String>("dpiY").ToLocalChecked(), Nan::New<Integer>(value.DpiY));

    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);
  }

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

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

    private:

      IPrintDocumentSource(::Windows::Graphics::Printing::IPrintDocumentSource^ 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::Graphics::Printing::IPrintDocumentSource^ winRtInstance;


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

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

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







    private:
      ::Windows::Graphics::Printing::IPrintDocumentSource^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIPrintDocumentSource(::Windows::Graphics::Printing::IPrintDocumentSource^ wintRtInstance);
      friend ::Windows::Graphics::Printing::IPrintDocumentSource^ UnwrapIPrintDocumentSource(Local<Value> value);
  };

  Persistent<FunctionTemplate> IPrintDocumentSource::s_constructorTemplate;

  v8::Local<v8::Value> WrapIPrintDocumentSource(::Windows::Graphics::Printing::IPrintDocumentSource^ 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>(IPrintDocumentSource::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Graphics::Printing::IPrintDocumentSource^ UnwrapIPrintDocumentSource(Local<Value> value) {
     return IPrintDocumentSource::Unwrap<IPrintDocumentSource>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIPrintDocumentSource(Local<Object> exports) {
    IPrintDocumentSource::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getPageDescription", GetPageDescription);
          




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



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

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

    private:

      IPrintTaskOptionsCore(::Windows::Graphics::Printing::IPrintTaskOptionsCore^ 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::Graphics::Printing::IPrintTaskOptionsCore^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::IPrintTaskOptionsCore^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsUint32())
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          
          ::Windows::Graphics::Printing::PrintPageDescription result;
          result = wrapper->_instance->GetPageDescription(arg0);
          info.GetReturnValue().Set(PrintPageDescriptionToJsObject(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::Graphics::Printing::IPrintTaskOptionsCore^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIPrintTaskOptionsCore(::Windows::Graphics::Printing::IPrintTaskOptionsCore^ wintRtInstance);
      friend ::Windows::Graphics::Printing::IPrintTaskOptionsCore^ UnwrapIPrintTaskOptionsCore(Local<Value> value);
  };

  Persistent<FunctionTemplate> IPrintTaskOptionsCore::s_constructorTemplate;

  v8::Local<v8::Value> WrapIPrintTaskOptionsCore(::Windows::Graphics::Printing::IPrintTaskOptionsCore^ 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>(IPrintTaskOptionsCore::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Graphics::Printing::IPrintTaskOptionsCore^ UnwrapIPrintTaskOptionsCore(Local<Value> value) {
     return IPrintTaskOptionsCore::Unwrap<IPrintTaskOptionsCore>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIPrintTaskOptionsCore(Local<Object> exports) {
    IPrintTaskOptionsCore::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("binding").ToLocalChecked(), BindingGetter, BindingSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("collation").ToLocalChecked(), CollationGetter, CollationSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("colorMode").ToLocalChecked(), ColorModeGetter, ColorModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("duplex").ToLocalChecked(), DuplexGetter, DuplexSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("holePunch").ToLocalChecked(), HolePunchGetter, HolePunchSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxCopies").ToLocalChecked(), MaxCopiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("mediaSize").ToLocalChecked(), MediaSizeGetter, MediaSizeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("mediaType").ToLocalChecked(), MediaTypeGetter, MediaTypeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("minCopies").ToLocalChecked(), MinCopiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("numberOfCopies").ToLocalChecked(), NumberOfCopiesGetter, NumberOfCopiesSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("orientation").ToLocalChecked(), OrientationGetter, OrientationSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("printQuality").ToLocalChecked(), PrintQualityGetter, PrintQualitySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("staple").ToLocalChecked(), StapleGetter, StapleSetter);

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



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

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

    private:

      IPrintTaskOptionsCoreProperties(::Windows::Graphics::Printing::IPrintTaskOptionsCoreProperties^ 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::Graphics::Printing::IPrintTaskOptionsCoreProperties^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::IPrintTaskOptionsCoreProperties^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Graphics::Printing::PrintBinding result = wrapper->_instance->Binding;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BindingSetter(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::Graphics::Printing::IPrintTaskOptionsCoreProperties^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Graphics::Printing::PrintBinding winRtValue = static_cast<::Windows::Graphics::Printing::PrintBinding>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::IPrintTaskOptionsCoreProperties^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Graphics::Printing::PrintCollation result = wrapper->_instance->Collation;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CollationSetter(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::Graphics::Printing::IPrintTaskOptionsCoreProperties^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Graphics::Printing::PrintCollation winRtValue = static_cast<::Windows::Graphics::Printing::PrintCollation>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::IPrintTaskOptionsCoreProperties^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Graphics::Printing::PrintColorMode result = wrapper->_instance->ColorMode;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ColorModeSetter(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::Graphics::Printing::IPrintTaskOptionsCoreProperties^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Graphics::Printing::PrintColorMode winRtValue = static_cast<::Windows::Graphics::Printing::PrintColorMode>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::IPrintTaskOptionsCoreProperties^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Graphics::Printing::PrintDuplex result = wrapper->_instance->Duplex;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DuplexSetter(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::Graphics::Printing::IPrintTaskOptionsCoreProperties^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Graphics::Printing::PrintDuplex winRtValue = static_cast<::Windows::Graphics::Printing::PrintDuplex>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::IPrintTaskOptionsCoreProperties^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Graphics::Printing::PrintHolePunch result = wrapper->_instance->HolePunch;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void HolePunchSetter(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::Graphics::Printing::IPrintTaskOptionsCoreProperties^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Graphics::Printing::PrintHolePunch winRtValue = static_cast<::Windows::Graphics::Printing::PrintHolePunch>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::IPrintTaskOptionsCoreProperties^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::IPrintTaskOptionsCoreProperties^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Graphics::Printing::PrintMediaSize result = wrapper->_instance->MediaSize;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MediaSizeSetter(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::Graphics::Printing::IPrintTaskOptionsCoreProperties^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Graphics::Printing::PrintMediaSize winRtValue = static_cast<::Windows::Graphics::Printing::PrintMediaSize>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::IPrintTaskOptionsCoreProperties^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Graphics::Printing::PrintMediaType result = wrapper->_instance->MediaType;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MediaTypeSetter(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::Graphics::Printing::IPrintTaskOptionsCoreProperties^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Graphics::Printing::PrintMediaType winRtValue = static_cast<::Windows::Graphics::Printing::PrintMediaType>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::IPrintTaskOptionsCoreProperties^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::IPrintTaskOptionsCoreProperties^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::IPrintTaskOptionsCoreProperties^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::IPrintTaskOptionsCoreProperties^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Graphics::Printing::PrintOrientation 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 OrientationSetter(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::Graphics::Printing::IPrintTaskOptionsCoreProperties^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Graphics::Printing::PrintOrientation winRtValue = static_cast<::Windows::Graphics::Printing::PrintOrientation>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::IPrintTaskOptionsCoreProperties^>(info.This())) {
        return;
      }

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

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

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

      try {

        ::Windows::Graphics::Printing::PrintQuality winRtValue = static_cast<::Windows::Graphics::Printing::PrintQuality>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::IPrintTaskOptionsCoreProperties^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Graphics::Printing::PrintStaple result = wrapper->_instance->Staple;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void StapleSetter(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::Graphics::Printing::IPrintTaskOptionsCoreProperties^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Graphics::Printing::PrintStaple winRtValue = static_cast<::Windows::Graphics::Printing::PrintStaple>(Nan::To<int32_t>(value).FromMaybe(0));

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


    private:
      ::Windows::Graphics::Printing::IPrintTaskOptionsCoreProperties^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIPrintTaskOptionsCoreProperties(::Windows::Graphics::Printing::IPrintTaskOptionsCoreProperties^ wintRtInstance);
      friend ::Windows::Graphics::Printing::IPrintTaskOptionsCoreProperties^ UnwrapIPrintTaskOptionsCoreProperties(Local<Value> value);
  };

  Persistent<FunctionTemplate> IPrintTaskOptionsCoreProperties::s_constructorTemplate;

  v8::Local<v8::Value> WrapIPrintTaskOptionsCoreProperties(::Windows::Graphics::Printing::IPrintTaskOptionsCoreProperties^ 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>(IPrintTaskOptionsCoreProperties::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Graphics::Printing::IPrintTaskOptionsCoreProperties^ UnwrapIPrintTaskOptionsCoreProperties(Local<Value> value) {
     return IPrintTaskOptionsCoreProperties::Unwrap<IPrintTaskOptionsCoreProperties>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIPrintTaskOptionsCoreProperties(Local<Object> exports) {
    IPrintTaskOptionsCoreProperties::Init(exports);
  }

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





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

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



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

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

    private:

      IPrintTaskOptionsCoreUIConfiguration(::Windows::Graphics::Printing::IPrintTaskOptionsCoreUIConfiguration^ 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::Graphics::Printing::IPrintTaskOptionsCoreUIConfiguration^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::IPrintTaskOptionsCoreUIConfiguration^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Graphics::Printing::IPrintTaskOptionsCoreUIConfiguration^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapIPrintTaskOptionsCoreUIConfiguration(::Windows::Graphics::Printing::IPrintTaskOptionsCoreUIConfiguration^ wintRtInstance);
      friend ::Windows::Graphics::Printing::IPrintTaskOptionsCoreUIConfiguration^ UnwrapIPrintTaskOptionsCoreUIConfiguration(Local<Value> value);
  };

  Persistent<FunctionTemplate> IPrintTaskOptionsCoreUIConfiguration::s_constructorTemplate;

  v8::Local<v8::Value> WrapIPrintTaskOptionsCoreUIConfiguration(::Windows::Graphics::Printing::IPrintTaskOptionsCoreUIConfiguration^ 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>(IPrintTaskOptionsCoreUIConfiguration::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Graphics::Printing::IPrintTaskOptionsCoreUIConfiguration^ UnwrapIPrintTaskOptionsCoreUIConfiguration(Local<Value> value) {
     return IPrintTaskOptionsCoreUIConfiguration::Unwrap<IPrintTaskOptionsCoreUIConfiguration>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitIPrintTaskOptionsCoreUIConfiguration(Local<Object> exports) {
    IPrintTaskOptionsCoreUIConfiguration::Init(exports);
  }

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

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



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


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

        Nan::SetMethod(constructor, "isSupported", IsSupported);
        Nan::SetMethod(constructor, "getForCurrentView", GetForCurrentView);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(ShowPrintUIAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("showPrintUIAsync").ToLocalChecked(), func);


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

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

    private:

      PrintManager(::Windows::Graphics::Printing::PrintManager^ 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::Graphics::Printing::PrintManager^ winRtInstance;


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

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

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




    static void ShowPrintUIAsync(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() == 1)
      {
        try
        {
          op = ::Windows::Graphics::Printing::PrintManager::ShowPrintUIAsync();
        } catch (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 IsSupported(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          bool result;
          result = ::Windows::Graphics::Printing::PrintManager::IsSupported();
          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 GetForCurrentView(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Graphics::Printing::PrintManager^ result;
          result = ::Windows::Graphics::Printing::PrintManager::GetForCurrentView();
          info.GetReturnValue().Set(WrapPrintManager(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 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"printTaskRequested", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintManager^>(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;
        }
        PrintManager *wrapper = PrintManager::Unwrap<PrintManager>(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->PrintTaskRequested::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Graphics::Printing::PrintManager^, ::Windows::Graphics::Printing::PrintTaskRequestedEventArgs^>(
            [callbackObjPtr](::Windows::Graphics::Printing::PrintManager^ arg0, ::Windows::Graphics::Printing::PrintTaskRequestedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPrintManager(arg0);
                  wrappedArg1 = WrapPrintTaskRequestedEventArgs(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"printTaskRequested", 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"printTaskRequested", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintManager^>(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;
          }
          PrintManager *wrapper = PrintManager::Unwrap<PrintManager>(info.This());
          wrapper->_instance->PrintTaskRequested::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::Graphics::Printing::PrintManager^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPrintManager(::Windows::Graphics::Printing::PrintManager^ wintRtInstance);
      friend ::Windows::Graphics::Printing::PrintManager^ UnwrapPrintManager(Local<Value> value);
  };

  Persistent<FunctionTemplate> PrintManager::s_constructorTemplate;

  v8::Local<v8::Value> WrapPrintManager(::Windows::Graphics::Printing::PrintManager^ 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>(PrintManager::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Graphics::Printing::PrintManager^ UnwrapPrintManager(Local<Value> value) {
     return PrintManager::Unwrap<PrintManager>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPrintManager(Local<Object> exports) {
    PrintManager::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pageSize").ToLocalChecked(), PageSizeGetter, PageSizeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("orientation").ToLocalChecked(), OrientationGetter, OrientationSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("mediaSize").ToLocalChecked(), MediaSizeGetter, MediaSizeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dpiY").ToLocalChecked(), DpiYGetter, DpiYSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("dpiX").ToLocalChecked(), DpiXGetter, DpiXSetter);

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



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

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

    private:

      PrintPageInfo(::Windows::Graphics::Printing::PrintPageInfo^ 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::Graphics::Printing::PrintPageInfo^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintPageInfo^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Size result = wrapper->_instance->PageSize;
        info.GetReturnValue().Set(NodeRT::Utils::SizeToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PageSizeSetter(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::Graphics::Printing::PrintPageInfo^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintPageInfo^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Graphics::Printing::PrintOrientation 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 OrientationSetter(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::Graphics::Printing::PrintPageInfo^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Graphics::Printing::PrintOrientation winRtValue = static_cast<::Windows::Graphics::Printing::PrintOrientation>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintPageInfo^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Graphics::Printing::PrintMediaSize result = wrapper->_instance->MediaSize;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MediaSizeSetter(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::Graphics::Printing::PrintPageInfo^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Graphics::Printing::PrintMediaSize winRtValue = static_cast<::Windows::Graphics::Printing::PrintMediaSize>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintPageInfo^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintPageInfo^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintPageInfo^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintPageInfo^>(info.This())) {
        return;
      }

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

      try {

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

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


    private:
      ::Windows::Graphics::Printing::PrintPageInfo^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPrintPageInfo(::Windows::Graphics::Printing::PrintPageInfo^ wintRtInstance);
      friend ::Windows::Graphics::Printing::PrintPageInfo^ UnwrapPrintPageInfo(Local<Value> value);
  };

  Persistent<FunctionTemplate> PrintPageInfo::s_constructorTemplate;

  v8::Local<v8::Value> WrapPrintPageInfo(::Windows::Graphics::Printing::PrintPageInfo^ 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>(PrintPageInfo::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Graphics::Printing::PrintPageInfo^ UnwrapPrintPageInfo(Local<Value> value) {
     return PrintPageInfo::Unwrap<PrintPageInfo>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPrintPageInfo(Local<Object> exports) {
    PrintPageInfo::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("firstPageNumber").ToLocalChecked(), FirstPageNumberGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("lastPageNumber").ToLocalChecked(), LastPageNumberGetter);

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



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

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

    private:

      PrintPageRange(::Windows::Graphics::Printing::PrintPageRange^ 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::Graphics::Printing::PrintPageRange^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintPageRange^>(info[0])) {
        try {
          winRtInstance = (::Windows::Graphics::Printing::PrintPageRange^) NodeRT::Utils::GetObjectInstance(info[0]);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && 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));
          
          winRtInstance = ref new ::Windows::Graphics::Printing::PrintPageRange(arg0,arg1);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try {
          int arg0 = static_cast<int>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          winRtInstance = ref new ::Windows::Graphics::Printing::PrintPageRange(arg0);
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Invalid arguments, no suitable constructor found")));
        return;
      }

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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintPageRange^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintPageRange^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Graphics::Printing::PrintPageRange^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPrintPageRange(::Windows::Graphics::Printing::PrintPageRange^ wintRtInstance);
      friend ::Windows::Graphics::Printing::PrintPageRange^ UnwrapPrintPageRange(Local<Value> value);
  };

  Persistent<FunctionTemplate> PrintPageRange::s_constructorTemplate;

  v8::Local<v8::Value> WrapPrintPageRange(::Windows::Graphics::Printing::PrintPageRange^ 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>(PrintPageRange::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Graphics::Printing::PrintPageRange^ UnwrapPrintPageRange(Local<Value> value) {
     return PrintPageRange::Unwrap<PrintPageRange>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPrintPageRange(Local<Object> exports) {
    PrintPageRange::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("allowCustomSetOfPages").ToLocalChecked(), AllowCustomSetOfPagesGetter, AllowCustomSetOfPagesSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("allowCurrentPage").ToLocalChecked(), AllowCurrentPageGetter, AllowCurrentPageSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("allowAllPages").ToLocalChecked(), AllowAllPagesGetter, AllowAllPagesSetter);

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



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

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

    private:

      PrintPageRangeOptions(::Windows::Graphics::Printing::PrintPageRangeOptions^ 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::Graphics::Printing::PrintPageRangeOptions^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintPageRangeOptions^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintPageRangeOptions^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintPageRangeOptions^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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


    private:
      ::Windows::Graphics::Printing::PrintPageRangeOptions^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPrintPageRangeOptions(::Windows::Graphics::Printing::PrintPageRangeOptions^ wintRtInstance);
      friend ::Windows::Graphics::Printing::PrintPageRangeOptions^ UnwrapPrintPageRangeOptions(Local<Value> value);
  };

  Persistent<FunctionTemplate> PrintPageRangeOptions::s_constructorTemplate;

  v8::Local<v8::Value> WrapPrintPageRangeOptions(::Windows::Graphics::Printing::PrintPageRangeOptions^ 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>(PrintPageRangeOptions::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Graphics::Printing::PrintPageRangeOptions^ UnwrapPrintPageRangeOptions(Local<Value> value) {
     return PrintPageRangeOptions::Unwrap<PrintPageRangeOptions>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPrintPageRangeOptions(Local<Object> exports) {
    PrintPageRangeOptions::Init(exports);
  }

  class PrintTask : 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>("PrintTask").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>("options").ToLocalChecked(), OptionsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("properties").ToLocalChecked(), PropertiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("source").ToLocalChecked(), SourceGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isPreviewEnabled").ToLocalChecked(), IsPreviewEnabledGetter, IsPreviewEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isPrinterTargetEnabled").ToLocalChecked(), IsPrinterTargetEnabledGetter, IsPrinterTargetEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("is3DManufacturingTargetEnabled").ToLocalChecked(), Is3DManufacturingTargetEnabledGetter, Is3DManufacturingTargetEnabledSetter);

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



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

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

    private:

      PrintTask(::Windows::Graphics::Printing::PrintTask^ 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::Graphics::Printing::PrintTask^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTask^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Graphics::Printing::PrintTaskOptions^ result = wrapper->_instance->Options;
        info.GetReturnValue().Set(WrapPrintTaskOptions(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PropertiesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTask^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTask^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Graphics::Printing::IPrintDocumentSource^ result = wrapper->_instance->Source;
        info.GetReturnValue().Set(WrapIPrintDocumentSource(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsPreviewEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTask^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTask^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTask^>(info.This())) {
        return;
      }

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

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

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

      try {

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

        wrapper->_instance->Is3DManufacturingTargetEnabled = 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"completed", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTask^>(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;
        }
        PrintTask *wrapper = PrintTask::Unwrap<PrintTask>(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->Completed::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Graphics::Printing::PrintTask^, ::Windows::Graphics::Printing::PrintTaskCompletedEventArgs^>(
            [callbackObjPtr](::Windows::Graphics::Printing::PrintTask^ arg0, ::Windows::Graphics::Printing::PrintTaskCompletedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPrintTask(arg0);
                  wrappedArg1 = WrapPrintTaskCompletedEventArgs(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"previewing", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTask^>(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;
        }
        PrintTask *wrapper = PrintTask::Unwrap<PrintTask>(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->Previewing::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Graphics::Printing::PrintTask^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Graphics::Printing::PrintTask^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPrintTask(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"progressing", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTask^>(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;
        }
        PrintTask *wrapper = PrintTask::Unwrap<PrintTask>(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->Progressing::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Graphics::Printing::PrintTask^, ::Windows::Graphics::Printing::PrintTaskProgressingEventArgs^>(
            [callbackObjPtr](::Windows::Graphics::Printing::PrintTask^ arg0, ::Windows::Graphics::Printing::PrintTaskProgressingEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPrintTask(arg0);
                  wrappedArg1 = WrapPrintTaskProgressingEventArgs(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"submitting", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTask^>(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;
        }
        PrintTask *wrapper = PrintTask::Unwrap<PrintTask>(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->Submitting::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Graphics::Printing::PrintTask^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Graphics::Printing::PrintTask^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapPrintTask(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"completed", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"previewing", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"progressing", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"submitting", 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"completed", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTask^>(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;
          }
          PrintTask *wrapper = PrintTask::Unwrap<PrintTask>(info.This());
          wrapper->_instance->Completed::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"previewing", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTask^>(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;
          }
          PrintTask *wrapper = PrintTask::Unwrap<PrintTask>(info.This());
          wrapper->_instance->Previewing::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"progressing", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTask^>(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;
          }
          PrintTask *wrapper = PrintTask::Unwrap<PrintTask>(info.This());
          wrapper->_instance->Progressing::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"submitting", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTask^>(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;
          }
          PrintTask *wrapper = PrintTask::Unwrap<PrintTask>(info.This());
          wrapper->_instance->Submitting::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::Graphics::Printing::PrintTask^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPrintTask(::Windows::Graphics::Printing::PrintTask^ wintRtInstance);
      friend ::Windows::Graphics::Printing::PrintTask^ UnwrapPrintTask(Local<Value> value);
  };

  Persistent<FunctionTemplate> PrintTask::s_constructorTemplate;

  v8::Local<v8::Value> WrapPrintTask(::Windows::Graphics::Printing::PrintTask^ 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>(PrintTask::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Graphics::Printing::PrintTask^ UnwrapPrintTask(Local<Value> value) {
     return PrintTask::Unwrap<PrintTask>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPrintTask(Local<Object> exports) {
    PrintTask::Init(exports);
  }

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





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

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



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

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

    private:

      PrintTaskCompletedEventArgs(::Windows::Graphics::Printing::PrintTaskCompletedEventArgs^ 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::Graphics::Printing::PrintTaskCompletedEventArgs^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskCompletedEventArgs^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Graphics::Printing::PrintTaskCompletedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPrintTaskCompletedEventArgs(::Windows::Graphics::Printing::PrintTaskCompletedEventArgs^ wintRtInstance);
      friend ::Windows::Graphics::Printing::PrintTaskCompletedEventArgs^ UnwrapPrintTaskCompletedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> PrintTaskCompletedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapPrintTaskCompletedEventArgs(::Windows::Graphics::Printing::PrintTaskCompletedEventArgs^ 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>(PrintTaskCompletedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Graphics::Printing::PrintTaskCompletedEventArgs^ UnwrapPrintTaskCompletedEventArgs(Local<Value> value) {
     return PrintTaskCompletedEventArgs::Unwrap<PrintTaskCompletedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPrintTaskCompletedEventArgs(Local<Object> exports) {
    PrintTaskCompletedEventArgs::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getPageDescription", GetPageDescription);
            Nan::SetPrototypeMethod(localRef, "getPagePrintTicket", GetPagePrintTicket);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("bordering").ToLocalChecked(), BorderingGetter, BorderingSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pageRangeOptions").ToLocalChecked(), PageRangeOptionsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("customPageRanges").ToLocalChecked(), CustomPageRangesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("mediaType").ToLocalChecked(), MediaTypeGetter, MediaTypeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("holePunch").ToLocalChecked(), HolePunchGetter, HolePunchSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("binding").ToLocalChecked(), BindingGetter, BindingSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("duplex").ToLocalChecked(), DuplexGetter, DuplexSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("colorMode").ToLocalChecked(), ColorModeGetter, ColorModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("collation").ToLocalChecked(), CollationGetter, CollationSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("staple").ToLocalChecked(), StapleGetter, StapleSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("printQuality").ToLocalChecked(), PrintQualityGetter, PrintQualitySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("orientation").ToLocalChecked(), OrientationGetter, OrientationSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("mediaSize").ToLocalChecked(), MediaSizeGetter, MediaSizeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("numberOfCopies").ToLocalChecked(), NumberOfCopiesGetter, NumberOfCopiesSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxCopies").ToLocalChecked(), MaxCopiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("minCopies").ToLocalChecked(), MinCopiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("displayedOptions").ToLocalChecked(), DisplayedOptionsGetter);

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



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

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

    private:

      PrintTaskOptions(::Windows::Graphics::Printing::PrintTaskOptions^ 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::Graphics::Printing::PrintTaskOptions^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsUint32())
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          
          ::Windows::Graphics::Printing::PrintPageDescription result;
          result = wrapper->_instance->GetPageDescription(arg0);
          info.GetReturnValue().Set(PrintPageDescriptionToJsObject(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 GetPagePrintTicket(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintPageInfo^>(info[0]))
      {
        try
        {
          ::Windows::Graphics::Printing::PrintPageInfo^ arg0 = UnwrapPrintPageInfo(info[0]);
          
          ::Windows::Storage::Streams::IRandomAccessStream^ result;
          result = wrapper->_instance->GetPagePrintTicket(arg0);
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Storage.Streams", "IRandomAccessStream", 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 BorderingGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Graphics::Printing::PrintBordering result = wrapper->_instance->Bordering;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BorderingSetter(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::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Graphics::Printing::PrintBordering winRtValue = static_cast<::Windows::Graphics::Printing::PrintBordering>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Graphics::Printing::PrintPageRangeOptions^ result = wrapper->_instance->PageRangeOptions;
        info.GetReturnValue().Set(WrapPrintPageRangeOptions(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CustomPageRangesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVector<::Windows::Graphics::Printing::PrintPageRange^>^ result = wrapper->_instance->CustomPageRanges;
        info.GetReturnValue().Set(NodeRT::Collections::VectorWrapper<::Windows::Graphics::Printing::PrintPageRange^>::CreateVectorWrapper(result, 
            [](::Windows::Graphics::Printing::PrintPageRange^ val) -> Local<Value> {
              return WrapPrintPageRange(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintPageRange^>(value);
            },
            [](Local<Value> value) -> ::Windows::Graphics::Printing::PrintPageRange^ {
              return UnwrapPrintPageRange(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MediaTypeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Graphics::Printing::PrintMediaType result = wrapper->_instance->MediaType;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MediaTypeSetter(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::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Graphics::Printing::PrintMediaType winRtValue = static_cast<::Windows::Graphics::Printing::PrintMediaType>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Graphics::Printing::PrintHolePunch result = wrapper->_instance->HolePunch;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void HolePunchSetter(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::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Graphics::Printing::PrintHolePunch winRtValue = static_cast<::Windows::Graphics::Printing::PrintHolePunch>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Graphics::Printing::PrintBinding result = wrapper->_instance->Binding;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BindingSetter(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::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Graphics::Printing::PrintBinding winRtValue = static_cast<::Windows::Graphics::Printing::PrintBinding>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Graphics::Printing::PrintDuplex result = wrapper->_instance->Duplex;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DuplexSetter(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::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Graphics::Printing::PrintDuplex winRtValue = static_cast<::Windows::Graphics::Printing::PrintDuplex>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Graphics::Printing::PrintColorMode result = wrapper->_instance->ColorMode;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ColorModeSetter(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::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Graphics::Printing::PrintColorMode winRtValue = static_cast<::Windows::Graphics::Printing::PrintColorMode>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Graphics::Printing::PrintCollation result = wrapper->_instance->Collation;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CollationSetter(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::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Graphics::Printing::PrintCollation winRtValue = static_cast<::Windows::Graphics::Printing::PrintCollation>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Graphics::Printing::PrintStaple result = wrapper->_instance->Staple;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void StapleSetter(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::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Graphics::Printing::PrintStaple winRtValue = static_cast<::Windows::Graphics::Printing::PrintStaple>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

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

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

      try {

        ::Windows::Graphics::Printing::PrintQuality winRtValue = static_cast<::Windows::Graphics::Printing::PrintQuality>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Graphics::Printing::PrintOrientation 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 OrientationSetter(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::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Graphics::Printing::PrintOrientation winRtValue = static_cast<::Windows::Graphics::Printing::PrintOrientation>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Graphics::Printing::PrintMediaSize result = wrapper->_instance->MediaSize;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MediaSizeSetter(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::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Graphics::Printing::PrintMediaSize winRtValue = static_cast<::Windows::Graphics::Printing::PrintMediaSize>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskOptions^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Graphics::Printing::PrintTaskOptions^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPrintTaskOptions(::Windows::Graphics::Printing::PrintTaskOptions^ wintRtInstance);
      friend ::Windows::Graphics::Printing::PrintTaskOptions^ UnwrapPrintTaskOptions(Local<Value> value);
  };

  Persistent<FunctionTemplate> PrintTaskOptions::s_constructorTemplate;

  v8::Local<v8::Value> WrapPrintTaskOptions(::Windows::Graphics::Printing::PrintTaskOptions^ 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>(PrintTaskOptions::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Graphics::Printing::PrintTaskOptions^ UnwrapPrintTaskOptions(Local<Value> value) {
     return PrintTaskOptions::Unwrap<PrintTaskOptions>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPrintTaskOptions(Local<Object> exports) {
    PrintTaskOptions::Init(exports);
  }

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





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

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



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

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

    private:

      PrintTaskProgressingEventArgs(::Windows::Graphics::Printing::PrintTaskProgressingEventArgs^ 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::Graphics::Printing::PrintTaskProgressingEventArgs^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskProgressingEventArgs^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Graphics::Printing::PrintTaskProgressingEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPrintTaskProgressingEventArgs(::Windows::Graphics::Printing::PrintTaskProgressingEventArgs^ wintRtInstance);
      friend ::Windows::Graphics::Printing::PrintTaskProgressingEventArgs^ UnwrapPrintTaskProgressingEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> PrintTaskProgressingEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapPrintTaskProgressingEventArgs(::Windows::Graphics::Printing::PrintTaskProgressingEventArgs^ 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>(PrintTaskProgressingEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Graphics::Printing::PrintTaskProgressingEventArgs^ UnwrapPrintTaskProgressingEventArgs(Local<Value> value) {
     return PrintTaskProgressingEventArgs::Unwrap<PrintTaskProgressingEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPrintTaskProgressingEventArgs(Local<Object> exports) {
    PrintTaskProgressingEventArgs::Init(exports);
  }

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


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



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

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



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

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

    private:

      PrintTaskRequest(::Windows::Graphics::Printing::PrintTaskRequest^ 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::Graphics::Printing::PrintTaskRequest^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskRequest^>(info.This())) {
        return;
      }

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

      if (info.Length() == 2
        && info[0]->IsString()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskSourceRequestedHandler^>(info[1]))
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Graphics::Printing::PrintTaskSourceRequestedHandler^ arg1 = dynamic_cast<::Windows::Graphics::Printing::PrintTaskSourceRequestedHandler^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          ::Windows::Graphics::Printing::PrintTask^ result;
          result = wrapper->_instance->CreatePrintTask(arg0, arg1);
          info.GetReturnValue().Set(WrapPrintTask(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 GetDeferral(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskRequest^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Graphics::Printing::PrintTaskRequestedDeferral^ result;
          result = wrapper->_instance->GetDeferral();
          info.GetReturnValue().Set(WrapPrintTaskRequestedDeferral(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 DeadlineGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskRequest^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Graphics::Printing::PrintTaskRequest^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPrintTaskRequest(::Windows::Graphics::Printing::PrintTaskRequest^ wintRtInstance);
      friend ::Windows::Graphics::Printing::PrintTaskRequest^ UnwrapPrintTaskRequest(Local<Value> value);
  };

  Persistent<FunctionTemplate> PrintTaskRequest::s_constructorTemplate;

  v8::Local<v8::Value> WrapPrintTaskRequest(::Windows::Graphics::Printing::PrintTaskRequest^ 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>(PrintTaskRequest::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Graphics::Printing::PrintTaskRequest^ UnwrapPrintTaskRequest(Local<Value> value) {
     return PrintTaskRequest::Unwrap<PrintTaskRequest>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPrintTaskRequest(Local<Object> exports) {
    PrintTaskRequest::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "complete", Complete);
          




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



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

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

    private:

      PrintTaskRequestedDeferral(::Windows::Graphics::Printing::PrintTaskRequestedDeferral^ 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::Graphics::Printing::PrintTaskRequestedDeferral^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskRequestedDeferral^>(info.This())) {
        return;
      }

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

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





    private:
      ::Windows::Graphics::Printing::PrintTaskRequestedDeferral^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPrintTaskRequestedDeferral(::Windows::Graphics::Printing::PrintTaskRequestedDeferral^ wintRtInstance);
      friend ::Windows::Graphics::Printing::PrintTaskRequestedDeferral^ UnwrapPrintTaskRequestedDeferral(Local<Value> value);
  };

  Persistent<FunctionTemplate> PrintTaskRequestedDeferral::s_constructorTemplate;

  v8::Local<v8::Value> WrapPrintTaskRequestedDeferral(::Windows::Graphics::Printing::PrintTaskRequestedDeferral^ 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>(PrintTaskRequestedDeferral::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Graphics::Printing::PrintTaskRequestedDeferral^ UnwrapPrintTaskRequestedDeferral(Local<Value> value) {
     return PrintTaskRequestedDeferral::Unwrap<PrintTaskRequestedDeferral>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPrintTaskRequestedDeferral(Local<Object> exports) {
    PrintTaskRequestedDeferral::Init(exports);
  }

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





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

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



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

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

    private:

      PrintTaskRequestedEventArgs(::Windows::Graphics::Printing::PrintTaskRequestedEventArgs^ 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::Graphics::Printing::PrintTaskRequestedEventArgs^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskRequestedEventArgs^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Graphics::Printing::PrintTaskRequest^ result = wrapper->_instance->Request;
        info.GetReturnValue().Set(WrapPrintTaskRequest(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Graphics::Printing::PrintTaskRequestedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPrintTaskRequestedEventArgs(::Windows::Graphics::Printing::PrintTaskRequestedEventArgs^ wintRtInstance);
      friend ::Windows::Graphics::Printing::PrintTaskRequestedEventArgs^ UnwrapPrintTaskRequestedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> PrintTaskRequestedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapPrintTaskRequestedEventArgs(::Windows::Graphics::Printing::PrintTaskRequestedEventArgs^ 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>(PrintTaskRequestedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Graphics::Printing::PrintTaskRequestedEventArgs^ UnwrapPrintTaskRequestedEventArgs(Local<Value> value) {
     return PrintTaskRequestedEventArgs::Unwrap<PrintTaskRequestedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPrintTaskRequestedEventArgs(Local<Object> exports) {
    PrintTaskRequestedEventArgs::Init(exports);
  }

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


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



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

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



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

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

    private:

      PrintTaskSourceRequestedArgs(::Windows::Graphics::Printing::PrintTaskSourceRequestedArgs^ 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::Graphics::Printing::PrintTaskSourceRequestedArgs^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskSourceRequestedArgs^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::IPrintDocumentSource^>(info[0]))
      {
        try
        {
          ::Windows::Graphics::Printing::IPrintDocumentSource^ arg0 = UnwrapIPrintDocumentSource(info[0]);
          
          wrapper->_instance->SetSource(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 GetDeferral(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskSourceRequestedArgs^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Graphics::Printing::PrintTaskSourceRequestedDeferral^ result;
          result = wrapper->_instance->GetDeferral();
          info.GetReturnValue().Set(WrapPrintTaskSourceRequestedDeferral(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 DeadlineGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskSourceRequestedArgs^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Graphics::Printing::PrintTaskSourceRequestedArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPrintTaskSourceRequestedArgs(::Windows::Graphics::Printing::PrintTaskSourceRequestedArgs^ wintRtInstance);
      friend ::Windows::Graphics::Printing::PrintTaskSourceRequestedArgs^ UnwrapPrintTaskSourceRequestedArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> PrintTaskSourceRequestedArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapPrintTaskSourceRequestedArgs(::Windows::Graphics::Printing::PrintTaskSourceRequestedArgs^ 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>(PrintTaskSourceRequestedArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Graphics::Printing::PrintTaskSourceRequestedArgs^ UnwrapPrintTaskSourceRequestedArgs(Local<Value> value) {
     return PrintTaskSourceRequestedArgs::Unwrap<PrintTaskSourceRequestedArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPrintTaskSourceRequestedArgs(Local<Object> exports) {
    PrintTaskSourceRequestedArgs::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "complete", Complete);
          




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



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

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

    private:

      PrintTaskSourceRequestedDeferral(::Windows::Graphics::Printing::PrintTaskSourceRequestedDeferral^ 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::Graphics::Printing::PrintTaskSourceRequestedDeferral^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Graphics::Printing::PrintTaskSourceRequestedDeferral^>(info.This())) {
        return;
      }

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

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





    private:
      ::Windows::Graphics::Printing::PrintTaskSourceRequestedDeferral^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPrintTaskSourceRequestedDeferral(::Windows::Graphics::Printing::PrintTaskSourceRequestedDeferral^ wintRtInstance);
      friend ::Windows::Graphics::Printing::PrintTaskSourceRequestedDeferral^ UnwrapPrintTaskSourceRequestedDeferral(Local<Value> value);
  };

  Persistent<FunctionTemplate> PrintTaskSourceRequestedDeferral::s_constructorTemplate;

  v8::Local<v8::Value> WrapPrintTaskSourceRequestedDeferral(::Windows::Graphics::Printing::PrintTaskSourceRequestedDeferral^ 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>(PrintTaskSourceRequestedDeferral::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Graphics::Printing::PrintTaskSourceRequestedDeferral^ UnwrapPrintTaskSourceRequestedDeferral(Local<Value> value) {
     return PrintTaskSourceRequestedDeferral::Unwrap<PrintTaskSourceRequestedDeferral>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPrintTaskSourceRequestedDeferral(Local<Object> exports) {
    PrintTaskSourceRequestedDeferral::Init(exports);
  }

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






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

        Nan::SetAccessor(constructor, Nan::New<String>("copies").ToLocalChecked(), CopiesGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("binding").ToLocalChecked(), BindingGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("collation").ToLocalChecked(), CollationGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("colorMode").ToLocalChecked(), ColorModeGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("mediaType").ToLocalChecked(), MediaTypeGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("duplex").ToLocalChecked(), DuplexGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("holePunch").ToLocalChecked(), HolePunchGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("inputBin").ToLocalChecked(), InputBinGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("mediaSize").ToLocalChecked(), MediaSizeGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("nUp").ToLocalChecked(), NUpGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("orientation").ToLocalChecked(), OrientationGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("printQuality").ToLocalChecked(), PrintQualityGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("staple").ToLocalChecked(), StapleGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("bordering").ToLocalChecked(), BorderingGetter);
        Nan::SetAccessor(constructor, Nan::New<String>("customPageRanges").ToLocalChecked(), CustomPageRangesGetter);


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

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

    private:

      StandardPrintTaskOptions(::Windows::Graphics::Printing::StandardPrintTaskOptions^ 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::Graphics::Printing::StandardPrintTaskOptions^ winRtInstance;


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

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

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







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

      try
      {
        Platform::String^ result = ::Windows::Graphics::Printing::StandardPrintTaskOptions::Copies;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Graphics::Printing::StandardPrintTaskOptions::Binding;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Graphics::Printing::StandardPrintTaskOptions::Collation;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Graphics::Printing::StandardPrintTaskOptions::ColorMode;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Graphics::Printing::StandardPrintTaskOptions::MediaType;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Graphics::Printing::StandardPrintTaskOptions::Duplex;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Graphics::Printing::StandardPrintTaskOptions::HolePunch;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Graphics::Printing::StandardPrintTaskOptions::InputBin;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Graphics::Printing::StandardPrintTaskOptions::MediaSize;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Graphics::Printing::StandardPrintTaskOptions::NUp;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Graphics::Printing::StandardPrintTaskOptions::Orientation;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Graphics::Printing::StandardPrintTaskOptions::PrintQuality;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Graphics::Printing::StandardPrintTaskOptions::Staple;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Graphics::Printing::StandardPrintTaskOptions::Bordering;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

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

      try
      {
        Platform::String^ result = ::Windows::Graphics::Printing::StandardPrintTaskOptions::CustomPageRanges;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      

    private:
      ::Windows::Graphics::Printing::StandardPrintTaskOptions^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapStandardPrintTaskOptions(::Windows::Graphics::Printing::StandardPrintTaskOptions^ wintRtInstance);
      friend ::Windows::Graphics::Printing::StandardPrintTaskOptions^ UnwrapStandardPrintTaskOptions(Local<Value> value);
  };

  Persistent<FunctionTemplate> StandardPrintTaskOptions::s_constructorTemplate;

  v8::Local<v8::Value> WrapStandardPrintTaskOptions(::Windows::Graphics::Printing::StandardPrintTaskOptions^ 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>(StandardPrintTaskOptions::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Graphics::Printing::StandardPrintTaskOptions^ UnwrapStandardPrintTaskOptions(Local<Value> value) {
     return StandardPrintTaskOptions::Unwrap<StandardPrintTaskOptions>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitStandardPrintTaskOptions(Local<Object> exports) {
    StandardPrintTaskOptions::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::Graphics::Printing::InitPrintBindingEnum(target);
      NodeRT::Windows::Graphics::Printing::InitPrintBorderingEnum(target);
      NodeRT::Windows::Graphics::Printing::InitPrintCollationEnum(target);
      NodeRT::Windows::Graphics::Printing::InitPrintColorModeEnum(target);
      NodeRT::Windows::Graphics::Printing::InitPrintDuplexEnum(target);
      NodeRT::Windows::Graphics::Printing::InitPrintHolePunchEnum(target);
      NodeRT::Windows::Graphics::Printing::InitPrintMediaSizeEnum(target);
      NodeRT::Windows::Graphics::Printing::InitPrintMediaTypeEnum(target);
      NodeRT::Windows::Graphics::Printing::InitPrintOrientationEnum(target);
      NodeRT::Windows::Graphics::Printing::InitPrintQualityEnum(target);
      NodeRT::Windows::Graphics::Printing::InitPrintStapleEnum(target);
      NodeRT::Windows::Graphics::Printing::InitPrintTaskCompletionEnum(target);
      NodeRT::Windows::Graphics::Printing::InitIPrintDocumentSource(target);
      NodeRT::Windows::Graphics::Printing::InitIPrintTaskOptionsCore(target);
      NodeRT::Windows::Graphics::Printing::InitIPrintTaskOptionsCoreProperties(target);
      NodeRT::Windows::Graphics::Printing::InitIPrintTaskOptionsCoreUIConfiguration(target);
      NodeRT::Windows::Graphics::Printing::InitPrintManager(target);
      NodeRT::Windows::Graphics::Printing::InitPrintPageInfo(target);
      NodeRT::Windows::Graphics::Printing::InitPrintPageRange(target);
      NodeRT::Windows::Graphics::Printing::InitPrintPageRangeOptions(target);
      NodeRT::Windows::Graphics::Printing::InitPrintTask(target);
      NodeRT::Windows::Graphics::Printing::InitPrintTaskCompletedEventArgs(target);
      NodeRT::Windows::Graphics::Printing::InitPrintTaskOptions(target);
      NodeRT::Windows::Graphics::Printing::InitPrintTaskProgressingEventArgs(target);
      NodeRT::Windows::Graphics::Printing::InitPrintTaskRequest(target);
      NodeRT::Windows::Graphics::Printing::InitPrintTaskRequestedDeferral(target);
      NodeRT::Windows::Graphics::Printing::InitPrintTaskRequestedEventArgs(target);
      NodeRT::Windows::Graphics::Printing::InitPrintTaskSourceRequestedArgs(target);
      NodeRT::Windows::Graphics::Printing::InitPrintTaskSourceRequestedDeferral(target);
      NodeRT::Windows::Graphics::Printing::InitStandardPrintTaskOptions(target);


  NodeRT::Utils::RegisterNameSpace("Windows.Graphics.Printing", target);
}



NODE_MODULE(binding, init)