// 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 Media { namespace Capture { 
  v8::Local<v8::Value> WrapAppCapture(::Windows::Media::Capture::AppCapture^ wintRtInstance);
  ::Windows::Media::Capture::AppCapture^ UnwrapAppCapture(Local<Value> value);
  
  v8::Local<v8::Value> WrapCameraCaptureUIPhotoCaptureSettings(::Windows::Media::Capture::CameraCaptureUIPhotoCaptureSettings^ wintRtInstance);
  ::Windows::Media::Capture::CameraCaptureUIPhotoCaptureSettings^ UnwrapCameraCaptureUIPhotoCaptureSettings(Local<Value> value);
  
  v8::Local<v8::Value> WrapCameraCaptureUIVideoCaptureSettings(::Windows::Media::Capture::CameraCaptureUIVideoCaptureSettings^ wintRtInstance);
  ::Windows::Media::Capture::CameraCaptureUIVideoCaptureSettings^ UnwrapCameraCaptureUIVideoCaptureSettings(Local<Value> value);
  
  v8::Local<v8::Value> WrapCameraCaptureUI(::Windows::Media::Capture::CameraCaptureUI^ wintRtInstance);
  ::Windows::Media::Capture::CameraCaptureUI^ UnwrapCameraCaptureUI(Local<Value> value);
  
  v8::Local<v8::Value> WrapMediaCaptureFailedEventArgs(::Windows::Media::Capture::MediaCaptureFailedEventArgs^ wintRtInstance);
  ::Windows::Media::Capture::MediaCaptureFailedEventArgs^ UnwrapMediaCaptureFailedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapMediaCapture(::Windows::Media::Capture::MediaCapture^ wintRtInstance);
  ::Windows::Media::Capture::MediaCapture^ UnwrapMediaCapture(Local<Value> value);
  
  v8::Local<v8::Value> WrapMediaCaptureVideoProfileMediaDescription(::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^ wintRtInstance);
  ::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^ UnwrapMediaCaptureVideoProfileMediaDescription(Local<Value> value);
  
  v8::Local<v8::Value> WrapMediaCaptureVideoProfile(::Windows::Media::Capture::MediaCaptureVideoProfile^ wintRtInstance);
  ::Windows::Media::Capture::MediaCaptureVideoProfile^ UnwrapMediaCaptureVideoProfile(Local<Value> value);
  
  v8::Local<v8::Value> WrapMediaCaptureInitializationSettings(::Windows::Media::Capture::MediaCaptureInitializationSettings^ wintRtInstance);
  ::Windows::Media::Capture::MediaCaptureInitializationSettings^ UnwrapMediaCaptureInitializationSettings(Local<Value> value);
  
  v8::Local<v8::Value> WrapMediaCaptureSettings(::Windows::Media::Capture::MediaCaptureSettings^ wintRtInstance);
  ::Windows::Media::Capture::MediaCaptureSettings^ UnwrapMediaCaptureSettings(Local<Value> value);
  
  v8::Local<v8::Value> WrapLowLagMediaRecording(::Windows::Media::Capture::LowLagMediaRecording^ wintRtInstance);
  ::Windows::Media::Capture::LowLagMediaRecording^ UnwrapLowLagMediaRecording(Local<Value> value);
  
  v8::Local<v8::Value> WrapLowLagPhotoCapture(::Windows::Media::Capture::LowLagPhotoCapture^ wintRtInstance);
  ::Windows::Media::Capture::LowLagPhotoCapture^ UnwrapLowLagPhotoCapture(Local<Value> value);
  
  v8::Local<v8::Value> WrapLowLagPhotoSequenceCapture(::Windows::Media::Capture::LowLagPhotoSequenceCapture^ wintRtInstance);
  ::Windows::Media::Capture::LowLagPhotoSequenceCapture^ UnwrapLowLagPhotoSequenceCapture(Local<Value> value);
  
  v8::Local<v8::Value> WrapMediaCaptureFocusChangedEventArgs(::Windows::Media::Capture::MediaCaptureFocusChangedEventArgs^ wintRtInstance);
  ::Windows::Media::Capture::MediaCaptureFocusChangedEventArgs^ UnwrapMediaCaptureFocusChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapPhotoConfirmationCapturedEventArgs(::Windows::Media::Capture::PhotoConfirmationCapturedEventArgs^ wintRtInstance);
  ::Windows::Media::Capture::PhotoConfirmationCapturedEventArgs^ UnwrapPhotoConfirmationCapturedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapAdvancedPhotoCapture(::Windows::Media::Capture::AdvancedPhotoCapture^ wintRtInstance);
  ::Windows::Media::Capture::AdvancedPhotoCapture^ UnwrapAdvancedPhotoCapture(Local<Value> value);
  
  v8::Local<v8::Value> WrapMediaCapturePauseResult(::Windows::Media::Capture::MediaCapturePauseResult^ wintRtInstance);
  ::Windows::Media::Capture::MediaCapturePauseResult^ UnwrapMediaCapturePauseResult(Local<Value> value);
  
  v8::Local<v8::Value> WrapMediaCaptureStopResult(::Windows::Media::Capture::MediaCaptureStopResult^ wintRtInstance);
  ::Windows::Media::Capture::MediaCaptureStopResult^ UnwrapMediaCaptureStopResult(Local<Value> value);
  
  v8::Local<v8::Value> WrapMediaCaptureDeviceExclusiveControlStatusChangedEventArgs(::Windows::Media::Capture::MediaCaptureDeviceExclusiveControlStatusChangedEventArgs^ wintRtInstance);
  ::Windows::Media::Capture::MediaCaptureDeviceExclusiveControlStatusChangedEventArgs^ UnwrapMediaCaptureDeviceExclusiveControlStatusChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapCapturedPhoto(::Windows::Media::Capture::CapturedPhoto^ wintRtInstance);
  ::Windows::Media::Capture::CapturedPhoto^ UnwrapCapturedPhoto(Local<Value> value);
  
  v8::Local<v8::Value> WrapAdvancedCapturedPhoto(::Windows::Media::Capture::AdvancedCapturedPhoto^ wintRtInstance);
  ::Windows::Media::Capture::AdvancedCapturedPhoto^ UnwrapAdvancedCapturedPhoto(Local<Value> value);
  
  v8::Local<v8::Value> WrapOptionalReferencePhotoCapturedEventArgs(::Windows::Media::Capture::OptionalReferencePhotoCapturedEventArgs^ wintRtInstance);
  ::Windows::Media::Capture::OptionalReferencePhotoCapturedEventArgs^ UnwrapOptionalReferencePhotoCapturedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapCapturedFrame(::Windows::Media::Capture::CapturedFrame^ wintRtInstance);
  ::Windows::Media::Capture::CapturedFrame^ UnwrapCapturedFrame(Local<Value> value);
  
  v8::Local<v8::Value> WrapPhotoCapturedEventArgs(::Windows::Media::Capture::PhotoCapturedEventArgs^ wintRtInstance);
  ::Windows::Media::Capture::PhotoCapturedEventArgs^ UnwrapPhotoCapturedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapCapturedFrameControlValues(::Windows::Media::Capture::CapturedFrameControlValues^ wintRtInstance);
  ::Windows::Media::Capture::CapturedFrameControlValues^ UnwrapCapturedFrameControlValues(Local<Value> value);
  
  v8::Local<v8::Value> WrapVideoStreamConfiguration(::Windows::Media::Capture::VideoStreamConfiguration^ wintRtInstance);
  ::Windows::Media::Capture::VideoStreamConfiguration^ UnwrapVideoStreamConfiguration(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppBroadcastGlobalSettings(::Windows::Media::Capture::AppBroadcastGlobalSettings^ wintRtInstance);
  ::Windows::Media::Capture::AppBroadcastGlobalSettings^ UnwrapAppBroadcastGlobalSettings(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppBroadcastProviderSettings(::Windows::Media::Capture::AppBroadcastProviderSettings^ wintRtInstance);
  ::Windows::Media::Capture::AppBroadcastProviderSettings^ UnwrapAppBroadcastProviderSettings(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppBroadcastManager(::Windows::Media::Capture::AppBroadcastManager^ wintRtInstance);
  ::Windows::Media::Capture::AppBroadcastManager^ UnwrapAppBroadcastManager(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppBroadcastBackgroundServiceSignInInfo(::Windows::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^ wintRtInstance);
  ::Windows::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^ UnwrapAppBroadcastBackgroundServiceSignInInfo(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppBroadcastSignInStateChangedEventArgs(::Windows::Media::Capture::AppBroadcastSignInStateChangedEventArgs^ wintRtInstance);
  ::Windows::Media::Capture::AppBroadcastSignInStateChangedEventArgs^ UnwrapAppBroadcastSignInStateChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppBroadcastStreamReader(::Windows::Media::Capture::AppBroadcastStreamReader^ wintRtInstance);
  ::Windows::Media::Capture::AppBroadcastStreamReader^ UnwrapAppBroadcastStreamReader(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppBroadcastBackgroundServiceStreamInfo(::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^ wintRtInstance);
  ::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^ UnwrapAppBroadcastBackgroundServiceStreamInfo(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppBroadcastStreamStateChangedEventArgs(::Windows::Media::Capture::AppBroadcastStreamStateChangedEventArgs^ wintRtInstance);
  ::Windows::Media::Capture::AppBroadcastStreamStateChangedEventArgs^ UnwrapAppBroadcastStreamStateChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppBroadcastBackgroundService(::Windows::Media::Capture::AppBroadcastBackgroundService^ wintRtInstance);
  ::Windows::Media::Capture::AppBroadcastBackgroundService^ UnwrapAppBroadcastBackgroundService(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppBroadcastHeartbeatRequestedEventArgs(::Windows::Media::Capture::AppBroadcastHeartbeatRequestedEventArgs^ wintRtInstance);
  ::Windows::Media::Capture::AppBroadcastHeartbeatRequestedEventArgs^ UnwrapAppBroadcastHeartbeatRequestedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppBroadcastStreamAudioFrame(::Windows::Media::Capture::AppBroadcastStreamAudioFrame^ wintRtInstance);
  ::Windows::Media::Capture::AppBroadcastStreamAudioFrame^ UnwrapAppBroadcastStreamAudioFrame(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppBroadcastStreamVideoFrame(::Windows::Media::Capture::AppBroadcastStreamVideoFrame^ wintRtInstance);
  ::Windows::Media::Capture::AppBroadcastStreamVideoFrame^ UnwrapAppBroadcastStreamVideoFrame(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppBroadcastStreamVideoHeader(::Windows::Media::Capture::AppBroadcastStreamVideoHeader^ wintRtInstance);
  ::Windows::Media::Capture::AppBroadcastStreamVideoHeader^ UnwrapAppBroadcastStreamVideoHeader(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppBroadcastStreamAudioHeader(::Windows::Media::Capture::AppBroadcastStreamAudioHeader^ wintRtInstance);
  ::Windows::Media::Capture::AppBroadcastStreamAudioHeader^ UnwrapAppBroadcastStreamAudioHeader(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppBroadcastTriggerDetails(::Windows::Media::Capture::AppBroadcastTriggerDetails^ wintRtInstance);
  ::Windows::Media::Capture::AppBroadcastTriggerDetails^ UnwrapAppBroadcastTriggerDetails(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppBroadcastPlugInManager(::Windows::Media::Capture::AppBroadcastPlugInManager^ wintRtInstance);
  ::Windows::Media::Capture::AppBroadcastPlugInManager^ UnwrapAppBroadcastPlugInManager(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppBroadcastPlugIn(::Windows::Media::Capture::AppBroadcastPlugIn^ wintRtInstance);
  ::Windows::Media::Capture::AppBroadcastPlugIn^ UnwrapAppBroadcastPlugIn(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppBroadcastPreview(::Windows::Media::Capture::AppBroadcastPreview^ wintRtInstance);
  ::Windows::Media::Capture::AppBroadcastPreview^ UnwrapAppBroadcastPreview(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppBroadcastState(::Windows::Media::Capture::AppBroadcastState^ wintRtInstance);
  ::Windows::Media::Capture::AppBroadcastState^ UnwrapAppBroadcastState(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppBroadcastViewerCountChangedEventArgs(::Windows::Media::Capture::AppBroadcastViewerCountChangedEventArgs^ wintRtInstance);
  ::Windows::Media::Capture::AppBroadcastViewerCountChangedEventArgs^ UnwrapAppBroadcastViewerCountChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppBroadcastMicrophoneCaptureStateChangedEventArgs(::Windows::Media::Capture::AppBroadcastMicrophoneCaptureStateChangedEventArgs^ wintRtInstance);
  ::Windows::Media::Capture::AppBroadcastMicrophoneCaptureStateChangedEventArgs^ UnwrapAppBroadcastMicrophoneCaptureStateChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppBroadcastCameraCaptureStateChangedEventArgs(::Windows::Media::Capture::AppBroadcastCameraCaptureStateChangedEventArgs^ wintRtInstance);
  ::Windows::Media::Capture::AppBroadcastCameraCaptureStateChangedEventArgs^ UnwrapAppBroadcastCameraCaptureStateChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppBroadcastPlugInStateChangedEventArgs(::Windows::Media::Capture::AppBroadcastPlugInStateChangedEventArgs^ wintRtInstance);
  ::Windows::Media::Capture::AppBroadcastPlugInStateChangedEventArgs^ UnwrapAppBroadcastPlugInStateChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppBroadcastPreviewStateChangedEventArgs(::Windows::Media::Capture::AppBroadcastPreviewStateChangedEventArgs^ wintRtInstance);
  ::Windows::Media::Capture::AppBroadcastPreviewStateChangedEventArgs^ UnwrapAppBroadcastPreviewStateChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppBroadcastPreviewStreamReader(::Windows::Media::Capture::AppBroadcastPreviewStreamReader^ wintRtInstance);
  ::Windows::Media::Capture::AppBroadcastPreviewStreamReader^ UnwrapAppBroadcastPreviewStreamReader(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppBroadcastPreviewStreamVideoFrame(::Windows::Media::Capture::AppBroadcastPreviewStreamVideoFrame^ wintRtInstance);
  ::Windows::Media::Capture::AppBroadcastPreviewStreamVideoFrame^ UnwrapAppBroadcastPreviewStreamVideoFrame(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppBroadcastPreviewStreamVideoHeader(::Windows::Media::Capture::AppBroadcastPreviewStreamVideoHeader^ wintRtInstance);
  ::Windows::Media::Capture::AppBroadcastPreviewStreamVideoHeader^ UnwrapAppBroadcastPreviewStreamVideoHeader(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppBroadcastServices(::Windows::Media::Capture::AppBroadcastServices^ wintRtInstance);
  ::Windows::Media::Capture::AppBroadcastServices^ UnwrapAppBroadcastServices(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppCaptureSettings(::Windows::Media::Capture::AppCaptureSettings^ wintRtInstance);
  ::Windows::Media::Capture::AppCaptureSettings^ UnwrapAppCaptureSettings(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppCaptureAlternateShortcutKeys(::Windows::Media::Capture::AppCaptureAlternateShortcutKeys^ wintRtInstance);
  ::Windows::Media::Capture::AppCaptureAlternateShortcutKeys^ UnwrapAppCaptureAlternateShortcutKeys(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppCaptureManager(::Windows::Media::Capture::AppCaptureManager^ wintRtInstance);
  ::Windows::Media::Capture::AppCaptureManager^ UnwrapAppCaptureManager(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppCaptureRecordOperation(::Windows::Media::Capture::AppCaptureRecordOperation^ wintRtInstance);
  ::Windows::Media::Capture::AppCaptureRecordOperation^ UnwrapAppCaptureRecordOperation(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppCaptureState(::Windows::Media::Capture::AppCaptureState^ wintRtInstance);
  ::Windows::Media::Capture::AppCaptureState^ UnwrapAppCaptureState(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppCaptureMicrophoneCaptureStateChangedEventArgs(::Windows::Media::Capture::AppCaptureMicrophoneCaptureStateChangedEventArgs^ wintRtInstance);
  ::Windows::Media::Capture::AppCaptureMicrophoneCaptureStateChangedEventArgs^ UnwrapAppCaptureMicrophoneCaptureStateChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppCaptureRecordingStateChangedEventArgs(::Windows::Media::Capture::AppCaptureRecordingStateChangedEventArgs^ wintRtInstance);
  ::Windows::Media::Capture::AppCaptureRecordingStateChangedEventArgs^ UnwrapAppCaptureRecordingStateChangedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppCaptureDurationGeneratedEventArgs(::Windows::Media::Capture::AppCaptureDurationGeneratedEventArgs^ wintRtInstance);
  ::Windows::Media::Capture::AppCaptureDurationGeneratedEventArgs^ UnwrapAppCaptureDurationGeneratedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppCaptureFileGeneratedEventArgs(::Windows::Media::Capture::AppCaptureFileGeneratedEventArgs^ wintRtInstance);
  ::Windows::Media::Capture::AppCaptureFileGeneratedEventArgs^ UnwrapAppCaptureFileGeneratedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapAppCaptureServices(::Windows::Media::Capture::AppCaptureServices^ wintRtInstance);
  ::Windows::Media::Capture::AppCaptureServices^ UnwrapAppCaptureServices(Local<Value> value);
  
  v8::Local<v8::Value> WrapCameraOptionsUI(::Windows::Media::Capture::CameraOptionsUI^ wintRtInstance);
  ::Windows::Media::Capture::CameraOptionsUI^ UnwrapCameraOptionsUI(Local<Value> value);
  
  v8::Local<v8::Value> WrapGameBarServicesManager(::Windows::Media::Capture::GameBarServicesManager^ wintRtInstance);
  ::Windows::Media::Capture::GameBarServicesManager^ UnwrapGameBarServicesManager(Local<Value> value);
  
  v8::Local<v8::Value> WrapGameBarServicesManagerGameBarServicesCreatedEventArgs(::Windows::Media::Capture::GameBarServicesManagerGameBarServicesCreatedEventArgs^ wintRtInstance);
  ::Windows::Media::Capture::GameBarServicesManagerGameBarServicesCreatedEventArgs^ UnwrapGameBarServicesManagerGameBarServicesCreatedEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapGameBarServices(::Windows::Media::Capture::GameBarServices^ wintRtInstance);
  ::Windows::Media::Capture::GameBarServices^ UnwrapGameBarServices(Local<Value> value);
  
  v8::Local<v8::Value> WrapGameBarServicesTargetInfo(::Windows::Media::Capture::GameBarServicesTargetInfo^ wintRtInstance);
  ::Windows::Media::Capture::GameBarServicesTargetInfo^ UnwrapGameBarServicesTargetInfo(Local<Value> value);
  
  v8::Local<v8::Value> WrapGameBarServicesCommandEventArgs(::Windows::Media::Capture::GameBarServicesCommandEventArgs^ wintRtInstance);
  ::Windows::Media::Capture::GameBarServicesCommandEventArgs^ UnwrapGameBarServicesCommandEventArgs(Local<Value> value);
  
  v8::Local<v8::Value> WrapScreenCapture(::Windows::Media::Capture::ScreenCapture^ wintRtInstance);
  ::Windows::Media::Capture::ScreenCapture^ UnwrapScreenCapture(Local<Value> value);
  
  v8::Local<v8::Value> WrapSourceSuspensionChangedEventArgs(::Windows::Media::Capture::SourceSuspensionChangedEventArgs^ wintRtInstance);
  ::Windows::Media::Capture::SourceSuspensionChangedEventArgs^ UnwrapSourceSuspensionChangedEventArgs(Local<Value> value);
  



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

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

    Nan::Set(exports, Nan::New<String>("CameraCaptureUIMode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("photoOrVideo").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::CameraCaptureUIMode::PhotoOrVideo)));
    Nan::Set(enumObject, Nan::New<String>("photo").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::CameraCaptureUIMode::Photo)));
    Nan::Set(enumObject, Nan::New<String>("video").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::CameraCaptureUIMode::Video)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("CameraCaptureUIPhotoFormat").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("jpeg").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::CameraCaptureUIPhotoFormat::Jpeg)));
    Nan::Set(enumObject, Nan::New<String>("png").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::CameraCaptureUIPhotoFormat::Png)));
    Nan::Set(enumObject, Nan::New<String>("jpegXR").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::CameraCaptureUIPhotoFormat::JpegXR)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("CameraCaptureUIVideoFormat").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("mp4").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::CameraCaptureUIVideoFormat::Mp4)));
    Nan::Set(enumObject, Nan::New<String>("wmv").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::CameraCaptureUIVideoFormat::Wmv)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("CameraCaptureUIMaxVideoResolution").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("highestAvailable").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::CameraCaptureUIMaxVideoResolution::HighestAvailable)));
    Nan::Set(enumObject, Nan::New<String>("lowDefinition").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::CameraCaptureUIMaxVideoResolution::LowDefinition)));
    Nan::Set(enumObject, Nan::New<String>("standardDefinition").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::CameraCaptureUIMaxVideoResolution::StandardDefinition)));
    Nan::Set(enumObject, Nan::New<String>("highDefinition").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::CameraCaptureUIMaxVideoResolution::HighDefinition)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("CameraCaptureUIMaxPhotoResolution").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("highestAvailable").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::CameraCaptureUIMaxPhotoResolution::HighestAvailable)));
    Nan::Set(enumObject, Nan::New<String>("verySmallQvga").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::CameraCaptureUIMaxPhotoResolution::VerySmallQvga)));
    Nan::Set(enumObject, Nan::New<String>("smallVga").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::CameraCaptureUIMaxPhotoResolution::SmallVga)));
    Nan::Set(enumObject, Nan::New<String>("mediumXga").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::CameraCaptureUIMaxPhotoResolution::MediumXga)));
    Nan::Set(enumObject, Nan::New<String>("large3M").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::CameraCaptureUIMaxPhotoResolution::Large3M)));
    Nan::Set(enumObject, Nan::New<String>("veryLarge5M").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::CameraCaptureUIMaxPhotoResolution::VeryLarge5M)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("MediaCategory").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("other").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::MediaCategory::Other)));
    Nan::Set(enumObject, Nan::New<String>("communications").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::MediaCategory::Communications)));
    Nan::Set(enumObject, Nan::New<String>("media").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::MediaCategory::Media)));
    Nan::Set(enumObject, Nan::New<String>("gameChat").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::MediaCategory::GameChat)));
    Nan::Set(enumObject, Nan::New<String>("speech").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::MediaCategory::Speech)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("MediaStreamType").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("videoPreview").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::MediaStreamType::VideoPreview)));
    Nan::Set(enumObject, Nan::New<String>("videoRecord").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::MediaStreamType::VideoRecord)));
    Nan::Set(enumObject, Nan::New<String>("audio").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::MediaStreamType::Audio)));
    Nan::Set(enumObject, Nan::New<String>("photo").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::MediaStreamType::Photo)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("StreamingCaptureMode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("audioAndVideo").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::StreamingCaptureMode::AudioAndVideo)));
    Nan::Set(enumObject, Nan::New<String>("audio").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::StreamingCaptureMode::Audio)));
    Nan::Set(enumObject, Nan::New<String>("video").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::StreamingCaptureMode::Video)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("VideoRotation").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("none").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::VideoRotation::None)));
    Nan::Set(enumObject, Nan::New<String>("clockwise90Degrees").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::VideoRotation::Clockwise90Degrees)));
    Nan::Set(enumObject, Nan::New<String>("clockwise180Degrees").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::VideoRotation::Clockwise180Degrees)));
    Nan::Set(enumObject, Nan::New<String>("clockwise270Degrees").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::VideoRotation::Clockwise270Degrees)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("PhotoCaptureSource").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("auto").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::PhotoCaptureSource::Auto)));
    Nan::Set(enumObject, Nan::New<String>("videoPreview").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::PhotoCaptureSource::VideoPreview)));
    Nan::Set(enumObject, Nan::New<String>("photo").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::PhotoCaptureSource::Photo)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("VideoDeviceCharacteristic").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("allStreamsIndependent").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::VideoDeviceCharacteristic::AllStreamsIndependent)));
    Nan::Set(enumObject, Nan::New<String>("previewRecordStreamsIdentical").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::VideoDeviceCharacteristic::PreviewRecordStreamsIdentical)));
    Nan::Set(enumObject, Nan::New<String>("previewPhotoStreamsIdentical").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::VideoDeviceCharacteristic::PreviewPhotoStreamsIdentical)));
    Nan::Set(enumObject, Nan::New<String>("recordPhotoStreamsIdentical").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::VideoDeviceCharacteristic::RecordPhotoStreamsIdentical)));
    Nan::Set(enumObject, Nan::New<String>("allStreamsIdentical").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::VideoDeviceCharacteristic::AllStreamsIdentical)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("PowerlineFrequency").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("disabled").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::PowerlineFrequency::Disabled)));
    Nan::Set(enumObject, Nan::New<String>("fiftyHertz").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::PowerlineFrequency::FiftyHertz)));
    Nan::Set(enumObject, Nan::New<String>("sixtyHertz").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::PowerlineFrequency::SixtyHertz)));
    Nan::Set(enumObject, Nan::New<String>("auto").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::PowerlineFrequency::Auto)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("MediaCaptureThermalStatus").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("normal").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::MediaCaptureThermalStatus::Normal)));
    Nan::Set(enumObject, Nan::New<String>("overheated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::MediaCaptureThermalStatus::Overheated)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("MediaCaptureDeviceExclusiveControlStatus").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("exclusiveControlAvailable").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::MediaCaptureDeviceExclusiveControlStatus::ExclusiveControlAvailable)));
    Nan::Set(enumObject, Nan::New<String>("sharedReadOnlyAvailable").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::MediaCaptureDeviceExclusiveControlStatus::SharedReadOnlyAvailable)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("KnownVideoProfile").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("videoRecording").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::KnownVideoProfile::VideoRecording)));
    Nan::Set(enumObject, Nan::New<String>("highQualityPhoto").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::KnownVideoProfile::HighQualityPhoto)));
    Nan::Set(enumObject, Nan::New<String>("balancedVideoAndPhoto").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::KnownVideoProfile::BalancedVideoAndPhoto)));
    Nan::Set(enumObject, Nan::New<String>("videoConferencing").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::KnownVideoProfile::VideoConferencing)));
    Nan::Set(enumObject, Nan::New<String>("photoSequence").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::KnownVideoProfile::PhotoSequence)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("MediaCaptureMemoryPreference").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("auto").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::MediaCaptureMemoryPreference::Auto)));
    Nan::Set(enumObject, Nan::New<String>("cpu").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::MediaCaptureMemoryPreference::Cpu)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("MediaCaptureSharingMode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("exclusiveControl").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::MediaCaptureSharingMode::ExclusiveControl)));
    Nan::Set(enumObject, Nan::New<String>("sharedReadOnly").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::MediaCaptureSharingMode::SharedReadOnly)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("AppBroadcastCameraOverlayLocation").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("topLeft").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastCameraOverlayLocation::TopLeft)));
    Nan::Set(enumObject, Nan::New<String>("topCenter").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastCameraOverlayLocation::TopCenter)));
    Nan::Set(enumObject, Nan::New<String>("topRight").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastCameraOverlayLocation::TopRight)));
    Nan::Set(enumObject, Nan::New<String>("middleLeft").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastCameraOverlayLocation::MiddleLeft)));
    Nan::Set(enumObject, Nan::New<String>("middleCenter").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastCameraOverlayLocation::MiddleCenter)));
    Nan::Set(enumObject, Nan::New<String>("middleRight").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastCameraOverlayLocation::MiddleRight)));
    Nan::Set(enumObject, Nan::New<String>("bottomLeft").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastCameraOverlayLocation::BottomLeft)));
    Nan::Set(enumObject, Nan::New<String>("bottomCenter").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastCameraOverlayLocation::BottomCenter)));
    Nan::Set(enumObject, Nan::New<String>("bottomRight").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastCameraOverlayLocation::BottomRight)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("AppBroadcastCameraOverlaySize").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("small").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastCameraOverlaySize::Small)));
    Nan::Set(enumObject, Nan::New<String>("medium").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastCameraOverlaySize::Medium)));
    Nan::Set(enumObject, Nan::New<String>("large").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastCameraOverlaySize::Large)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("AppBroadcastVideoEncodingBitrateMode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("custom").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastVideoEncodingBitrateMode::Custom)));
    Nan::Set(enumObject, Nan::New<String>("auto").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastVideoEncodingBitrateMode::Auto)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("AppBroadcastVideoEncodingResolutionMode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("custom").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastVideoEncodingResolutionMode::Custom)));
    Nan::Set(enumObject, Nan::New<String>("auto").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastVideoEncodingResolutionMode::Auto)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("AppBroadcastPlugInState").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("unknown").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastPlugInState::Unknown)));
    Nan::Set(enumObject, Nan::New<String>("initialized").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastPlugInState::Initialized)));
    Nan::Set(enumObject, Nan::New<String>("microsoftSignInRequired").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastPlugInState::MicrosoftSignInRequired)));
    Nan::Set(enumObject, Nan::New<String>("oAuthSignInRequired").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastPlugInState::OAuthSignInRequired)));
    Nan::Set(enumObject, Nan::New<String>("providerSignInRequired").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastPlugInState::ProviderSignInRequired)));
    Nan::Set(enumObject, Nan::New<String>("inBandwidthTest").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastPlugInState::InBandwidthTest)));
    Nan::Set(enumObject, Nan::New<String>("readyToBroadcast").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastPlugInState::ReadyToBroadcast)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("AppBroadcastStreamState").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("initializing").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastStreamState::Initializing)));
    Nan::Set(enumObject, Nan::New<String>("streamReady").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastStreamState::StreamReady)));
    Nan::Set(enumObject, Nan::New<String>("started").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastStreamState::Started)));
    Nan::Set(enumObject, Nan::New<String>("paused").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastStreamState::Paused)));
    Nan::Set(enumObject, Nan::New<String>("terminated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastStreamState::Terminated)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("AppBroadcastSignInState").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("notSignedIn").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastSignInState::NotSignedIn)));
    Nan::Set(enumObject, Nan::New<String>("microsoftSignInInProgress").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastSignInState::MicrosoftSignInInProgress)));
    Nan::Set(enumObject, Nan::New<String>("microsoftSignInComplete").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastSignInState::MicrosoftSignInComplete)));
    Nan::Set(enumObject, Nan::New<String>("oAuthSignInInProgress").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastSignInState::OAuthSignInInProgress)));
    Nan::Set(enumObject, Nan::New<String>("oAuthSignInComplete").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastSignInState::OAuthSignInComplete)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("AppBroadcastTerminationReason").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("normalTermination").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastTerminationReason::NormalTermination)));
    Nan::Set(enumObject, Nan::New<String>("lostConnectionToService").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastTerminationReason::LostConnectionToService)));
    Nan::Set(enumObject, Nan::New<String>("noNetworkConnectivity").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastTerminationReason::NoNetworkConnectivity)));
    Nan::Set(enumObject, Nan::New<String>("serviceAbort").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastTerminationReason::ServiceAbort)));
    Nan::Set(enumObject, Nan::New<String>("serviceError").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastTerminationReason::ServiceError)));
    Nan::Set(enumObject, Nan::New<String>("serviceUnavailable").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastTerminationReason::ServiceUnavailable)));
    Nan::Set(enumObject, Nan::New<String>("internalError").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastTerminationReason::InternalError)));
    Nan::Set(enumObject, Nan::New<String>("unsupportedFormat").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastTerminationReason::UnsupportedFormat)));
    Nan::Set(enumObject, Nan::New<String>("backgroundTaskTerminated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastTerminationReason::BackgroundTaskTerminated)));
    Nan::Set(enumObject, Nan::New<String>("backgroundTaskUnresponsive").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastTerminationReason::BackgroundTaskUnresponsive)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("AppBroadcastSignInResult").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("success").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastSignInResult::Success)));
    Nan::Set(enumObject, Nan::New<String>("authenticationFailed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastSignInResult::AuthenticationFailed)));
    Nan::Set(enumObject, Nan::New<String>("unauthorized").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastSignInResult::Unauthorized)));
    Nan::Set(enumObject, Nan::New<String>("serviceUnavailable").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastSignInResult::ServiceUnavailable)));
    Nan::Set(enumObject, Nan::New<String>("unknown").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastSignInResult::Unknown)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("ForegroundActivationArgument").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("signInRequired").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::ForegroundActivationArgument::SignInRequired)));
    Nan::Set(enumObject, Nan::New<String>("moreSettings").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::ForegroundActivationArgument::MoreSettings)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("AppBroadcastMicrophoneCaptureState").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("stopped").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastMicrophoneCaptureState::Stopped)));
    Nan::Set(enumObject, Nan::New<String>("started").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastMicrophoneCaptureState::Started)));
    Nan::Set(enumObject, Nan::New<String>("failed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastMicrophoneCaptureState::Failed)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("AppBroadcastCameraCaptureState").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("stopped").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastCameraCaptureState::Stopped)));
    Nan::Set(enumObject, Nan::New<String>("started").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastCameraCaptureState::Started)));
    Nan::Set(enumObject, Nan::New<String>("failed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastCameraCaptureState::Failed)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("AppBroadcastExitBroadcastModeReason").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("normalExit").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastExitBroadcastModeReason::NormalExit)));
    Nan::Set(enumObject, Nan::New<String>("userCanceled").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastExitBroadcastModeReason::UserCanceled)));
    Nan::Set(enumObject, Nan::New<String>("authorizationFail").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastExitBroadcastModeReason::AuthorizationFail)));
    Nan::Set(enumObject, Nan::New<String>("foregroundAppActivated").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastExitBroadcastModeReason::ForegroundAppActivated)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("AppBroadcastPreviewState").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("started").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastPreviewState::Started)));
    Nan::Set(enumObject, Nan::New<String>("stopped").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastPreviewState::Stopped)));
    Nan::Set(enumObject, Nan::New<String>("failed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastPreviewState::Failed)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("AppBroadcastCaptureTargetType").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("appView").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastCaptureTargetType::AppView)));
    Nan::Set(enumObject, Nan::New<String>("entireDisplay").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppBroadcastCaptureTargetType::EntireDisplay)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("GameBarServicesDisplayMode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("windowed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::GameBarServicesDisplayMode::Windowed)));
    Nan::Set(enumObject, Nan::New<String>("fullScreenExclusive").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::GameBarServicesDisplayMode::FullScreenExclusive)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("AppCaptureVideoEncodingBitrateMode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("custom").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppCaptureVideoEncodingBitrateMode::Custom)));
    Nan::Set(enumObject, Nan::New<String>("high").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppCaptureVideoEncodingBitrateMode::High)));
    Nan::Set(enumObject, Nan::New<String>("standard").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppCaptureVideoEncodingBitrateMode::Standard)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("AppCaptureVideoEncodingResolutionMode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("custom").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppCaptureVideoEncodingResolutionMode::Custom)));
    Nan::Set(enumObject, Nan::New<String>("high").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppCaptureVideoEncodingResolutionMode::High)));
    Nan::Set(enumObject, Nan::New<String>("standard").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppCaptureVideoEncodingResolutionMode::Standard)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("AppCaptureVideoEncodingFrameRateMode").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("standard").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppCaptureVideoEncodingFrameRateMode::Standard)));
    Nan::Set(enumObject, Nan::New<String>("high").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppCaptureVideoEncodingFrameRateMode::High)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("AppCaptureHistoricalBufferLengthUnit").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("megabytes").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppCaptureHistoricalBufferLengthUnit::Megabytes)));
    Nan::Set(enumObject, Nan::New<String>("seconds").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppCaptureHistoricalBufferLengthUnit::Seconds)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("AppCaptureMicrophoneCaptureState").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("stopped").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppCaptureMicrophoneCaptureState::Stopped)));
    Nan::Set(enumObject, Nan::New<String>("started").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppCaptureMicrophoneCaptureState::Started)));
    Nan::Set(enumObject, Nan::New<String>("failed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppCaptureMicrophoneCaptureState::Failed)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("AppCaptureRecordingState").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("inProgress").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppCaptureRecordingState::InProgress)));
    Nan::Set(enumObject, Nan::New<String>("completed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppCaptureRecordingState::Completed)));
    Nan::Set(enumObject, Nan::New<String>("failed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::AppCaptureRecordingState::Failed)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("GameBarCommand").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("openGameBar").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::GameBarCommand::OpenGameBar)));
    Nan::Set(enumObject, Nan::New<String>("recordHistoricalBuffer").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::GameBarCommand::RecordHistoricalBuffer)));
    Nan::Set(enumObject, Nan::New<String>("toggleStartStopRecord").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::GameBarCommand::ToggleStartStopRecord)));
    Nan::Set(enumObject, Nan::New<String>("startRecord").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::GameBarCommand::StartRecord)));
    Nan::Set(enumObject, Nan::New<String>("stopRecord").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::GameBarCommand::StopRecord)));
    Nan::Set(enumObject, Nan::New<String>("takeScreenshot").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::GameBarCommand::TakeScreenshot)));
    Nan::Set(enumObject, Nan::New<String>("startBroadcast").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::GameBarCommand::StartBroadcast)));
    Nan::Set(enumObject, Nan::New<String>("stopBroadcast").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::GameBarCommand::StopBroadcast)));
    Nan::Set(enumObject, Nan::New<String>("pauseBroadcast").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::GameBarCommand::PauseBroadcast)));
    Nan::Set(enumObject, Nan::New<String>("resumeBroadcast").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::GameBarCommand::ResumeBroadcast)));
    Nan::Set(enumObject, Nan::New<String>("toggleStartStopBroadcast").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::GameBarCommand::ToggleStartStopBroadcast)));
    Nan::Set(enumObject, Nan::New<String>("toggleMicrophoneCapture").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::GameBarCommand::ToggleMicrophoneCapture)));
    Nan::Set(enumObject, Nan::New<String>("toggleCameraCapture").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::GameBarCommand::ToggleCameraCapture)));
    Nan::Set(enumObject, Nan::New<String>("toggleRecordingIndicator").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::GameBarCommand::ToggleRecordingIndicator)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("GameBarCommandOrigin").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("shortcutKey").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::GameBarCommandOrigin::ShortcutKey)));
    Nan::Set(enumObject, Nan::New<String>("cortana").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::GameBarCommandOrigin::Cortana)));
    Nan::Set(enumObject, Nan::New<String>("appCommand").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::GameBarCommandOrigin::AppCommand)));
  }

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

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

    Nan::Set(exports, Nan::New<String>("GameBarTargetCapturePolicy").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("enabledBySystem").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::GameBarTargetCapturePolicy::EnabledBySystem)));
    Nan::Set(enumObject, Nan::New<String>("enabledByUser").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::GameBarTargetCapturePolicy::EnabledByUser)));
    Nan::Set(enumObject, Nan::New<String>("notEnabled").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::GameBarTargetCapturePolicy::NotEnabled)));
    Nan::Set(enumObject, Nan::New<String>("prohibitedBySystem").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::GameBarTargetCapturePolicy::ProhibitedBySystem)));
    Nan::Set(enumObject, Nan::New<String>("prohibitedByPublisher").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Media::Capture::GameBarTargetCapturePolicy::ProhibitedByPublisher)));
  }

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

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

    symbol = Nan::New<String>("r").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("g").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    symbol = Nan::New<String>("b").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      if (!Nan::Get(obj,symbol).ToLocalChecked()->IsNumber()) {
        return false;
      }
    }
    
    return true;
  }

  ::Windows::Media::Capture::WhiteBalanceGain WhiteBalanceGainFromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::Media::Capture::WhiteBalanceGain 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>("r").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.R = Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0);
    }
    
    symbol = Nan::New<String>("g").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.G = Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0);
    }
    
    symbol = Nan::New<String>("b").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.B = Nan::To<double>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0.0);
    }
    
    return returnValue;
  }

  Local<Value> WhiteBalanceGainToJsObject(::Windows::Media::Capture::WhiteBalanceGain value) {
    EscapableHandleScope scope;

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

    Nan::Set(obj, Nan::New<String>("r").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.R)));
    Nan::Set(obj, Nan::New<String>("g").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.G)));
    Nan::Set(obj, Nan::New<String>("b").ToLocalChecked(), Nan::New<Number>(static_cast<double>(value.B)));

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

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

    return true;
  }

  ::Windows::Media::Capture::AppBroadcastContract AppBroadcastContractFromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::Media::Capture::AppBroadcastContract 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> AppBroadcastContractToJsObject(::Windows::Media::Capture::AppBroadcastContract value) {
    EscapableHandleScope scope;

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


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

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

    return true;
  }

  ::Windows::Media::Capture::AppCaptureContract AppCaptureContractFromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::Media::Capture::AppCaptureContract 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> AppCaptureContractToJsObject(::Windows::Media::Capture::AppCaptureContract value) {
    EscapableHandleScope scope;

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


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

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

    return true;
  }

  ::Windows::Media::Capture::CameraCaptureUIContract CameraCaptureUIContractFromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::Media::Capture::CameraCaptureUIContract 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> CameraCaptureUIContractToJsObject(::Windows::Media::Capture::CameraCaptureUIContract value) {
    EscapableHandleScope scope;

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


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

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

    return true;
  }

  ::Windows::Media::Capture::GameBarContract GameBarContractFromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::Media::Capture::GameBarContract 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> GameBarContractToJsObject(::Windows::Media::Capture::GameBarContract value) {
    EscapableHandleScope scope;

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


    return scope.Escape(obj);
  }

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

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

    return true;
  }

  ::Windows::Foundation::Size SizeFromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::Foundation::Size returnValue;

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

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

    return returnValue;
  }

  Local<Value> SizeToJsObject(::Windows::Foundation::Size value) {
    EscapableHandleScope scope;

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


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

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

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

  ::Windows::Graphics::Imaging::BitmapSize BitmapSizeFromJsObject(Local<Value> value) {
    HandleScope scope;
    ::Windows::Graphics::Imaging::BitmapSize 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>("width").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.Width = static_cast<unsigned int>(Nan::To<uint32_t>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0));
    }
    
    symbol = Nan::New<String>("height").ToLocalChecked();
    if (Nan::Has(obj, symbol).FromMaybe(false)) {
      returnValue.Height = static_cast<unsigned int>(Nan::To<uint32_t>(Nan::Get(obj,symbol).ToLocalChecked()).FromMaybe(0));
    }
    
    return returnValue;
  }

  Local<Value> BitmapSizeToJsObject(::Windows::Graphics::Imaging::BitmapSize value) {
    EscapableHandleScope scope;

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

    Nan::Set(obj, Nan::New<String>("width").ToLocalChecked(), Nan::New<Integer>(value.Width));
    Nan::Set(obj, Nan::New<String>("height").ToLocalChecked(), Nan::New<Integer>(value.Height));

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

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

    return true;
  }

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

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

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

    return returnValue;
  }

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

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


    return scope.Escape(obj);
  }

  class AppCapture : 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>("AppCapture").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>("isCapturingAudio").ToLocalChecked(), IsCapturingAudioGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isCapturingVideo").ToLocalChecked(), IsCapturingVideoGetter);

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

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


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

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

    private:

      AppCapture(::Windows::Media::Capture::AppCapture^ 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::Media::Capture::AppCapture^ winRtInstance;


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

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

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





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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Media::Capture::AppCapture^ result;
          result = ::Windows::Media::Capture::AppCapture::GetForCurrentView();
          info.GetReturnValue().Set(WrapAppCapture(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 IsCapturingAudioGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCapture^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCapture^>(info.This())) {
        return;
      }

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

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


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

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

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

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

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"capturingChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCapture^>(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;
        }
        AppCapture *wrapper = AppCapture::Unwrap<AppCapture>(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->CapturingChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::AppCapture^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Media::Capture::AppCapture^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAppCapture(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"capturingChanged", 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"capturingChanged", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCapture^>(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;
          }
          AppCapture *wrapper = AppCapture::Unwrap<AppCapture>(info.This());
          wrapper->_instance->CapturingChanged::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::Media::Capture::AppCapture^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppCapture(::Windows::Media::Capture::AppCapture^ wintRtInstance);
      friend ::Windows::Media::Capture::AppCapture^ UnwrapAppCapture(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppCapture::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppCapture(::Windows::Media::Capture::AppCapture^ 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>(AppCapture::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppCapture^ UnwrapAppCapture(Local<Value> value) {
     return AppCapture::Unwrap<AppCapture>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppCapture(Local<Object> exports) {
    AppCapture::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxResolution").ToLocalChecked(), MaxResolutionGetter, MaxResolutionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("format").ToLocalChecked(), FormatGetter, FormatSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("croppedSizeInPixels").ToLocalChecked(), CroppedSizeInPixelsGetter, CroppedSizeInPixelsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("croppedAspectRatio").ToLocalChecked(), CroppedAspectRatioGetter, CroppedAspectRatioSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("allowCropping").ToLocalChecked(), AllowCroppingGetter, AllowCroppingSetter);

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



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

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

    private:

      CameraCaptureUIPhotoCaptureSettings(::Windows::Media::Capture::CameraCaptureUIPhotoCaptureSettings^ 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::Media::Capture::CameraCaptureUIPhotoCaptureSettings^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CameraCaptureUIPhotoCaptureSettings^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Media::Capture::CameraCaptureUIMaxPhotoResolution result = wrapper->_instance->MaxResolution;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MaxResolutionSetter(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::Media::Capture::CameraCaptureUIPhotoCaptureSettings^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Media::Capture::CameraCaptureUIMaxPhotoResolution winRtValue = static_cast<::Windows::Media::Capture::CameraCaptureUIMaxPhotoResolution>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CameraCaptureUIPhotoCaptureSettings^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Media::Capture::CameraCaptureUIPhotoFormat result = wrapper->_instance->Format;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void FormatSetter(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::Media::Capture::CameraCaptureUIPhotoCaptureSettings^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Media::Capture::CameraCaptureUIPhotoFormat winRtValue = static_cast<::Windows::Media::Capture::CameraCaptureUIPhotoFormat>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CameraCaptureUIPhotoCaptureSettings^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Size result = wrapper->_instance->CroppedSizeInPixels;
        info.GetReturnValue().Set(NodeRT::Utils::SizeToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CroppedSizeInPixelsSetter(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::Media::Capture::CameraCaptureUIPhotoCaptureSettings^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CameraCaptureUIPhotoCaptureSettings^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Size result = wrapper->_instance->CroppedAspectRatio;
        info.GetReturnValue().Set(NodeRT::Utils::SizeToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CroppedAspectRatioSetter(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::Media::Capture::CameraCaptureUIPhotoCaptureSettings^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CameraCaptureUIPhotoCaptureSettings^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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


    private:
      ::Windows::Media::Capture::CameraCaptureUIPhotoCaptureSettings^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapCameraCaptureUIPhotoCaptureSettings(::Windows::Media::Capture::CameraCaptureUIPhotoCaptureSettings^ wintRtInstance);
      friend ::Windows::Media::Capture::CameraCaptureUIPhotoCaptureSettings^ UnwrapCameraCaptureUIPhotoCaptureSettings(Local<Value> value);
  };

  Persistent<FunctionTemplate> CameraCaptureUIPhotoCaptureSettings::s_constructorTemplate;

  v8::Local<v8::Value> WrapCameraCaptureUIPhotoCaptureSettings(::Windows::Media::Capture::CameraCaptureUIPhotoCaptureSettings^ 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>(CameraCaptureUIPhotoCaptureSettings::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::CameraCaptureUIPhotoCaptureSettings^ UnwrapCameraCaptureUIPhotoCaptureSettings(Local<Value> value) {
     return CameraCaptureUIPhotoCaptureSettings::Unwrap<CameraCaptureUIPhotoCaptureSettings>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitCameraCaptureUIPhotoCaptureSettings(Local<Object> exports) {
    CameraCaptureUIPhotoCaptureSettings::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxResolution").ToLocalChecked(), MaxResolutionGetter, MaxResolutionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maxDurationInSeconds").ToLocalChecked(), MaxDurationInSecondsGetter, MaxDurationInSecondsSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("format").ToLocalChecked(), FormatGetter, FormatSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("allowTrimming").ToLocalChecked(), AllowTrimmingGetter, AllowTrimmingSetter);

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



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

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

    private:

      CameraCaptureUIVideoCaptureSettings(::Windows::Media::Capture::CameraCaptureUIVideoCaptureSettings^ 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::Media::Capture::CameraCaptureUIVideoCaptureSettings^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CameraCaptureUIVideoCaptureSettings^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Media::Capture::CameraCaptureUIMaxVideoResolution result = wrapper->_instance->MaxResolution;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MaxResolutionSetter(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::Media::Capture::CameraCaptureUIVideoCaptureSettings^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Media::Capture::CameraCaptureUIMaxVideoResolution winRtValue = static_cast<::Windows::Media::Capture::CameraCaptureUIMaxVideoResolution>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CameraCaptureUIVideoCaptureSettings^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CameraCaptureUIVideoCaptureSettings^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CameraCaptureUIVideoCaptureSettings^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Media::Capture::CameraCaptureUIVideoFormat result = wrapper->_instance->Format;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void FormatSetter(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::Media::Capture::CameraCaptureUIVideoCaptureSettings^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Media::Capture::CameraCaptureUIVideoFormat winRtValue = static_cast<::Windows::Media::Capture::CameraCaptureUIVideoFormat>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CameraCaptureUIVideoCaptureSettings^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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


    private:
      ::Windows::Media::Capture::CameraCaptureUIVideoCaptureSettings^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapCameraCaptureUIVideoCaptureSettings(::Windows::Media::Capture::CameraCaptureUIVideoCaptureSettings^ wintRtInstance);
      friend ::Windows::Media::Capture::CameraCaptureUIVideoCaptureSettings^ UnwrapCameraCaptureUIVideoCaptureSettings(Local<Value> value);
  };

  Persistent<FunctionTemplate> CameraCaptureUIVideoCaptureSettings::s_constructorTemplate;

  v8::Local<v8::Value> WrapCameraCaptureUIVideoCaptureSettings(::Windows::Media::Capture::CameraCaptureUIVideoCaptureSettings^ 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>(CameraCaptureUIVideoCaptureSettings::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::CameraCaptureUIVideoCaptureSettings^ UnwrapCameraCaptureUIVideoCaptureSettings(Local<Value> value) {
     return CameraCaptureUIVideoCaptureSettings::Unwrap<CameraCaptureUIVideoCaptureSettings>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitCameraCaptureUIVideoCaptureSettings(Local<Object> exports) {
    CameraCaptureUIVideoCaptureSettings::Init(exports);
  }

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

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


          
            Nan::SetPrototypeMethod(localRef, "captureFileAsync", CaptureFileAsync);
          


          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("photoSettings").ToLocalChecked(), PhotoSettingsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoSettings").ToLocalChecked(), VideoSettingsGetter);

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



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

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

    private:

      CameraCaptureUI(::Windows::Media::Capture::CameraCaptureUI^ 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::Media::Capture::CameraCaptureUI^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CameraCaptureUI^>(info.This())) {
        return;
      }

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Storage::StorageFile^>^ op;


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

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

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


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.Storage", "StorageFile", 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 PhotoSettingsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CameraCaptureUI^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Media::Capture::CameraCaptureUIPhotoCaptureSettings^ result = wrapper->_instance->PhotoSettings;
        info.GetReturnValue().Set(WrapCameraCaptureUIPhotoCaptureSettings(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VideoSettingsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CameraCaptureUI^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Media::Capture::CameraCaptureUIVideoCaptureSettings^ result = wrapper->_instance->VideoSettings;
        info.GetReturnValue().Set(WrapCameraCaptureUIVideoCaptureSettings(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::CameraCaptureUI^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapCameraCaptureUI(::Windows::Media::Capture::CameraCaptureUI^ wintRtInstance);
      friend ::Windows::Media::Capture::CameraCaptureUI^ UnwrapCameraCaptureUI(Local<Value> value);
  };

  Persistent<FunctionTemplate> CameraCaptureUI::s_constructorTemplate;

  v8::Local<v8::Value> WrapCameraCaptureUI(::Windows::Media::Capture::CameraCaptureUI^ 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>(CameraCaptureUI::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::CameraCaptureUI^ UnwrapCameraCaptureUI(Local<Value> value) {
     return CameraCaptureUI::Unwrap<CameraCaptureUI>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitCameraCaptureUI(Local<Object> exports) {
    CameraCaptureUI::Init(exports);
  }

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





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

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



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

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

    private:

      MediaCaptureFailedEventArgs(::Windows::Media::Capture::MediaCaptureFailedEventArgs^ 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::Media::Capture::MediaCaptureFailedEventArgs^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureFailedEventArgs^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureFailedEventArgs^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Media::Capture::MediaCaptureFailedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMediaCaptureFailedEventArgs(::Windows::Media::Capture::MediaCaptureFailedEventArgs^ wintRtInstance);
      friend ::Windows::Media::Capture::MediaCaptureFailedEventArgs^ UnwrapMediaCaptureFailedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> MediaCaptureFailedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapMediaCaptureFailedEventArgs(::Windows::Media::Capture::MediaCaptureFailedEventArgs^ 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>(MediaCaptureFailedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::MediaCaptureFailedEventArgs^ UnwrapMediaCaptureFailedEventArgs(Local<Value> value) {
     return MediaCaptureFailedEventArgs::Unwrap<MediaCaptureFailedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMediaCaptureFailedEventArgs(Local<Object> exports) {
    MediaCaptureFailedEventArgs::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "setEncoderProperty", SetEncoderProperty);
            Nan::SetPrototypeMethod(localRef, "getEncoderProperty", GetEncoderProperty);
            Nan::SetPrototypeMethod(localRef, "setPreviewMirroring", SetPreviewMirroring);
            Nan::SetPrototypeMethod(localRef, "getPreviewMirroring", GetPreviewMirroring);
            Nan::SetPrototypeMethod(localRef, "setPreviewRotation", SetPreviewRotation);
            Nan::SetPrototypeMethod(localRef, "getPreviewRotation", GetPreviewRotation);
            Nan::SetPrototypeMethod(localRef, "setRecordRotation", SetRecordRotation);
            Nan::SetPrototypeMethod(localRef, "getRecordRotation", GetRecordRotation);
            Nan::SetPrototypeMethod(localRef, "close", Close);
          

          
            Nan::SetPrototypeMethod(localRef, "getPreviewFrameAsync", GetPreviewFrameAsync);
            Nan::SetPrototypeMethod(localRef, "prepareAdvancedPhotoCaptureAsync", PrepareAdvancedPhotoCaptureAsync);
            Nan::SetPrototypeMethod(localRef, "removeEffectAsync", RemoveEffectAsync);
            Nan::SetPrototypeMethod(localRef, "pauseRecordWithResultAsync", PauseRecordWithResultAsync);
            Nan::SetPrototypeMethod(localRef, "stopRecordWithResultAsync", StopRecordWithResultAsync);
            Nan::SetPrototypeMethod(localRef, "createFrameReaderAsync", CreateFrameReaderAsync);
            Nan::SetPrototypeMethod(localRef, "createMultiSourceFrameReaderAsync", CreateMultiSourceFrameReaderAsync);
            Nan::SetPrototypeMethod(localRef, "initializeAsync", InitializeAsync);
            Nan::SetPrototypeMethod(localRef, "startRecordToStorageFileAsync", StartRecordToStorageFileAsync);
            Nan::SetPrototypeMethod(localRef, "startRecordToStreamAsync", StartRecordToStreamAsync);
            Nan::SetPrototypeMethod(localRef, "startRecordToCustomSinkAsync", StartRecordToCustomSinkAsync);
            Nan::SetPrototypeMethod(localRef, "stopRecordAsync", StopRecordAsync);
            Nan::SetPrototypeMethod(localRef, "capturePhotoToStorageFileAsync", CapturePhotoToStorageFileAsync);
            Nan::SetPrototypeMethod(localRef, "capturePhotoToStreamAsync", CapturePhotoToStreamAsync);
            Nan::SetPrototypeMethod(localRef, "addEffectAsync", AddEffectAsync);
            Nan::SetPrototypeMethod(localRef, "clearEffectsAsync", ClearEffectsAsync);
            Nan::SetPrototypeMethod(localRef, "startPreviewAsync", StartPreviewAsync);
            Nan::SetPrototypeMethod(localRef, "startPreviewToCustomSinkAsync", StartPreviewToCustomSinkAsync);
            Nan::SetPrototypeMethod(localRef, "stopPreviewAsync", StopPreviewAsync);
            Nan::SetPrototypeMethod(localRef, "prepareLowLagRecordToStorageFileAsync", PrepareLowLagRecordToStorageFileAsync);
            Nan::SetPrototypeMethod(localRef, "prepareLowLagRecordToStreamAsync", PrepareLowLagRecordToStreamAsync);
            Nan::SetPrototypeMethod(localRef, "prepareLowLagRecordToCustomSinkAsync", PrepareLowLagRecordToCustomSinkAsync);
            Nan::SetPrototypeMethod(localRef, "prepareLowLagPhotoCaptureAsync", PrepareLowLagPhotoCaptureAsync);
            Nan::SetPrototypeMethod(localRef, "prepareLowLagPhotoSequenceCaptureAsync", PrepareLowLagPhotoSequenceCaptureAsync);
            Nan::SetPrototypeMethod(localRef, "setEncodingPropertiesAsync", SetEncodingPropertiesAsync);
            Nan::SetPrototypeMethod(localRef, "prepareVariablePhotoSequenceCaptureAsync", PrepareVariablePhotoSequenceCaptureAsync);
            Nan::SetPrototypeMethod(localRef, "addAudioEffectAsync", AddAudioEffectAsync);
            Nan::SetPrototypeMethod(localRef, "addVideoEffectAsync", AddVideoEffectAsync);
            Nan::SetPrototypeMethod(localRef, "pauseRecordAsync", PauseRecordAsync);
            Nan::SetPrototypeMethod(localRef, "resumeRecordAsync", ResumeRecordAsync);
          

          
          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>("audioDeviceController").ToLocalChecked(), AudioDeviceControllerGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("mediaCaptureSettings").ToLocalChecked(), MediaCaptureSettingsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoDeviceController").ToLocalChecked(), VideoDeviceControllerGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("cameraStreamState").ToLocalChecked(), CameraStreamStateGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("thermalStatus").ToLocalChecked(), ThermalStatusGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("frameSources").ToLocalChecked(), FrameSourcesGetter);

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

        Nan::SetMethod(constructor, "isVideoProfileSupported", IsVideoProfileSupported);
        Nan::SetMethod(constructor, "findAllVideoProfiles", FindAllVideoProfiles);
        Nan::SetMethod(constructor, "findConcurrentProfiles", FindConcurrentProfiles);
        Nan::SetMethod(constructor, "findKnownVideoProfiles", FindKnownVideoProfiles);


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

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

    private:

      MediaCapture(::Windows::Media::Capture::MediaCapture^ 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::Media::Capture::MediaCapture^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Media::VideoFrame^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->GetPreviewFrameAsync();
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::VideoFrame^>(info[0]))
      {
        try
        {
          ::Windows::Media::VideoFrame^ arg0 = dynamic_cast<::Windows::Media::VideoFrame^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          op = wrapper->_instance->GetPreviewFrameAsync(arg0);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.Media", "VideoFrame", 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 PrepareAdvancedPhotoCaptureAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Media::Capture::AdvancedPhotoCapture^>^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::MediaProperties::ImageEncodingProperties^>(info[0]))
      {
        try
        {
          ::Windows::Media::MediaProperties::ImageEncodingProperties^ arg0 = dynamic_cast<::Windows::Media::MediaProperties::ImageEncodingProperties^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          op = wrapper->_instance->PrepareAdvancedPhotoCaptureAsync(arg0);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

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


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::IMediaExtension^>(info[0]))
      {
        try
        {
          ::Windows::Media::IMediaExtension^ arg0 = dynamic_cast<::Windows::Media::IMediaExtension^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          op = wrapper->_instance->RemoveEffectAsync(arg0);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Media::Capture::MediaCapturePauseResult^>^ op;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Media::Capture::MediaCaptureStopResult^>^ op;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Media::Capture::Frames::MediaFrameReader^>^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::Frames::MediaFrameSource^>(info[0]))
      {
        try
        {
          ::Windows::Media::Capture::Frames::MediaFrameSource^ arg0 = dynamic_cast<::Windows::Media::Capture::Frames::MediaFrameSource^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          op = wrapper->_instance->CreateFrameReaderAsync(arg0);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::Frames::MediaFrameSource^>(info[0])
        && info[1]->IsString())
      {
        try
        {
          ::Windows::Media::Capture::Frames::MediaFrameSource^ arg0 = dynamic_cast<::Windows::Media::Capture::Frames::MediaFrameSource^>(NodeRT::Utils::GetObjectInstance(info[0]));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          
          op = wrapper->_instance->CreateFrameReaderAsync(arg0,arg1);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 4
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::Frames::MediaFrameSource^>(info[0])
        && info[1]->IsString()
        && IsBitmapSizeJsObject(info[2]))
      {
        try
        {
          ::Windows::Media::Capture::Frames::MediaFrameSource^ arg0 = dynamic_cast<::Windows::Media::Capture::Frames::MediaFrameSource^>(NodeRT::Utils::GetObjectInstance(info[0]));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          ::Windows::Graphics::Imaging::BitmapSize arg2 = BitmapSizeFromJsObject(info[2]);
          
          op = wrapper->_instance->CreateFrameReaderAsync(arg0,arg1,arg2);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.Media.Capture.Frames", "MediaFrameReader", 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 CreateMultiSourceFrameReaderAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Media::Capture::Frames::MultiSourceMediaFrameReader^>^ op;


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

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

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


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.Media.Capture.Frames", "MultiSourceMediaFrameReader", 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 InitializeAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

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


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->InitializeAsync();
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureInitializationSettings^>(info[0]))
      {
        try
        {
          ::Windows::Media::Capture::MediaCaptureInitializationSettings^ arg0 = UnwrapMediaCaptureInitializationSettings(info[0]);
          
          op = wrapper->_instance->InitializeAsync(arg0);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

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


      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::MediaProperties::MediaEncodingProfile^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::IStorageFile^>(info[1]))
      {
        try
        {
          ::Windows::Media::MediaProperties::MediaEncodingProfile^ arg0 = dynamic_cast<::Windows::Media::MediaProperties::MediaEncodingProfile^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Storage::IStorageFile^ arg1 = dynamic_cast<::Windows::Storage::IStorageFile^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          op = wrapper->_instance->StartRecordToStorageFileAsync(arg0,arg1);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

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


      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::MediaProperties::MediaEncodingProfile^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IRandomAccessStream^>(info[1]))
      {
        try
        {
          ::Windows::Media::MediaProperties::MediaEncodingProfile^ arg0 = dynamic_cast<::Windows::Media::MediaProperties::MediaEncodingProfile^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Storage::Streams::IRandomAccessStream^ arg1 = dynamic_cast<::Windows::Storage::Streams::IRandomAccessStream^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          op = wrapper->_instance->StartRecordToStreamAsync(arg0,arg1);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

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


      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::MediaProperties::MediaEncodingProfile^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::IMediaExtension^>(info[1]))
      {
        try
        {
          ::Windows::Media::MediaProperties::MediaEncodingProfile^ arg0 = dynamic_cast<::Windows::Media::MediaProperties::MediaEncodingProfile^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Media::IMediaExtension^ arg1 = dynamic_cast<::Windows::Media::IMediaExtension^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          op = wrapper->_instance->StartRecordToCustomSinkAsync(arg0,arg1);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 4
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::MediaProperties::MediaEncodingProfile^>(info[0])
        && info[1]->IsString()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IPropertySet^>(info[2]))
      {
        try
        {
          ::Windows::Media::MediaProperties::MediaEncodingProfile^ arg0 = dynamic_cast<::Windows::Media::MediaProperties::MediaEncodingProfile^>(NodeRT::Utils::GetObjectInstance(info[0]));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          ::Windows::Foundation::Collections::IPropertySet^ arg2 = dynamic_cast<::Windows::Foundation::Collections::IPropertySet^>(NodeRT::Utils::GetObjectInstance(info[2]));
          
          op = wrapper->_instance->StartRecordToCustomSinkAsync(arg0,arg1,arg2);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

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


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

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

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


      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::MediaProperties::ImageEncodingProperties^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::IStorageFile^>(info[1]))
      {
        try
        {
          ::Windows::Media::MediaProperties::ImageEncodingProperties^ arg0 = dynamic_cast<::Windows::Media::MediaProperties::ImageEncodingProperties^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Storage::IStorageFile^ arg1 = dynamic_cast<::Windows::Storage::IStorageFile^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          op = wrapper->_instance->CapturePhotoToStorageFileAsync(arg0,arg1);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

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


      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::MediaProperties::ImageEncodingProperties^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IRandomAccessStream^>(info[1]))
      {
        try
        {
          ::Windows::Media::MediaProperties::ImageEncodingProperties^ arg0 = dynamic_cast<::Windows::Media::MediaProperties::ImageEncodingProperties^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Storage::Streams::IRandomAccessStream^ arg1 = dynamic_cast<::Windows::Storage::Streams::IRandomAccessStream^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          op = wrapper->_instance->CapturePhotoToStreamAsync(arg0,arg1);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

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


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

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

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


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

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

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


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

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

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


      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::MediaProperties::MediaEncodingProfile^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::IMediaExtension^>(info[1]))
      {
        try
        {
          ::Windows::Media::MediaProperties::MediaEncodingProfile^ arg0 = dynamic_cast<::Windows::Media::MediaProperties::MediaEncodingProfile^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Media::IMediaExtension^ arg1 = dynamic_cast<::Windows::Media::IMediaExtension^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          op = wrapper->_instance->StartPreviewToCustomSinkAsync(arg0,arg1);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 4
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::MediaProperties::MediaEncodingProfile^>(info[0])
        && info[1]->IsString()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IPropertySet^>(info[2]))
      {
        try
        {
          ::Windows::Media::MediaProperties::MediaEncodingProfile^ arg0 = dynamic_cast<::Windows::Media::MediaProperties::MediaEncodingProfile^>(NodeRT::Utils::GetObjectInstance(info[0]));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          ::Windows::Foundation::Collections::IPropertySet^ arg2 = dynamic_cast<::Windows::Foundation::Collections::IPropertySet^>(NodeRT::Utils::GetObjectInstance(info[2]));
          
          op = wrapper->_instance->StartPreviewToCustomSinkAsync(arg0,arg1,arg2);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

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


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

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Media::Capture::LowLagMediaRecording^>^ op;


      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::MediaProperties::MediaEncodingProfile^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::IStorageFile^>(info[1]))
      {
        try
        {
          ::Windows::Media::MediaProperties::MediaEncodingProfile^ arg0 = dynamic_cast<::Windows::Media::MediaProperties::MediaEncodingProfile^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Storage::IStorageFile^ arg1 = dynamic_cast<::Windows::Storage::IStorageFile^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          op = wrapper->_instance->PrepareLowLagRecordToStorageFileAsync(arg0,arg1);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Media::Capture::LowLagMediaRecording^>^ op;


      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::MediaProperties::MediaEncodingProfile^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IRandomAccessStream^>(info[1]))
      {
        try
        {
          ::Windows::Media::MediaProperties::MediaEncodingProfile^ arg0 = dynamic_cast<::Windows::Media::MediaProperties::MediaEncodingProfile^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Storage::Streams::IRandomAccessStream^ arg1 = dynamic_cast<::Windows::Storage::Streams::IRandomAccessStream^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          op = wrapper->_instance->PrepareLowLagRecordToStreamAsync(arg0,arg1);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Media::Capture::LowLagMediaRecording^>^ op;


      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::MediaProperties::MediaEncodingProfile^>(info[0])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::IMediaExtension^>(info[1]))
      {
        try
        {
          ::Windows::Media::MediaProperties::MediaEncodingProfile^ arg0 = dynamic_cast<::Windows::Media::MediaProperties::MediaEncodingProfile^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Media::IMediaExtension^ arg1 = dynamic_cast<::Windows::Media::IMediaExtension^>(NodeRT::Utils::GetObjectInstance(info[1]));
          
          op = wrapper->_instance->PrepareLowLagRecordToCustomSinkAsync(arg0,arg1);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 4
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::MediaProperties::MediaEncodingProfile^>(info[0])
        && info[1]->IsString()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IPropertySet^>(info[2]))
      {
        try
        {
          ::Windows::Media::MediaProperties::MediaEncodingProfile^ arg0 = dynamic_cast<::Windows::Media::MediaProperties::MediaEncodingProfile^>(NodeRT::Utils::GetObjectInstance(info[0]));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
          ::Windows::Foundation::Collections::IPropertySet^ arg2 = dynamic_cast<::Windows::Foundation::Collections::IPropertySet^>(NodeRT::Utils::GetObjectInstance(info[2]));
          
          op = wrapper->_instance->PrepareLowLagRecordToCustomSinkAsync(arg0,arg1,arg2);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Media::Capture::LowLagPhotoCapture^>^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::MediaProperties::ImageEncodingProperties^>(info[0]))
      {
        try
        {
          ::Windows::Media::MediaProperties::ImageEncodingProperties^ arg0 = dynamic_cast<::Windows::Media::MediaProperties::ImageEncodingProperties^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          op = wrapper->_instance->PrepareLowLagPhotoCaptureAsync(arg0);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Media::Capture::LowLagPhotoSequenceCapture^>^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::MediaProperties::ImageEncodingProperties^>(info[0]))
      {
        try
        {
          ::Windows::Media::MediaProperties::ImageEncodingProperties^ arg0 = dynamic_cast<::Windows::Media::MediaProperties::ImageEncodingProperties^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          op = wrapper->_instance->PrepareLowLagPhotoSequenceCaptureAsync(arg0);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

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


      if (info.Length() == 4
        && info[0]->IsInt32()
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::MediaProperties::IMediaEncodingProperties^>(info[1])
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::MediaProperties::MediaPropertySet^>(info[2]))
      {
        try
        {
          ::Windows::Media::Capture::MediaStreamType arg0 = static_cast<::Windows::Media::Capture::MediaStreamType>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          ::Windows::Media::MediaProperties::IMediaEncodingProperties^ arg1 = dynamic_cast<::Windows::Media::MediaProperties::IMediaEncodingProperties^>(NodeRT::Utils::GetObjectInstance(info[1]));
          ::Windows::Media::MediaProperties::MediaPropertySet^ arg2 = dynamic_cast<::Windows::Media::MediaProperties::MediaPropertySet^>(NodeRT::Utils::GetObjectInstance(info[2]));
          
          op = wrapper->_instance->SetEncodingPropertiesAsync(arg0,arg1,arg2);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Media::Capture::Core::VariablePhotoSequenceCapture^>^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::MediaProperties::ImageEncodingProperties^>(info[0]))
      {
        try
        {
          ::Windows::Media::MediaProperties::ImageEncodingProperties^ arg0 = dynamic_cast<::Windows::Media::MediaProperties::ImageEncodingProperties^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          op = wrapper->_instance->PrepareVariablePhotoSequenceCaptureAsync(arg0);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.Media.Capture.Core", "VariablePhotoSequenceCapture", 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 AddAudioEffectAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Media::IMediaExtension^>^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Effects::IAudioEffectDefinition^>(info[0]))
      {
        try
        {
          ::Windows::Media::Effects::IAudioEffectDefinition^ arg0 = dynamic_cast<::Windows::Media::Effects::IAudioEffectDefinition^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          op = wrapper->_instance->AddAudioEffectAsync(arg0);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.Media", "IMediaExtension", 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 AddVideoEffectAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Media::IMediaExtension^>^ op;


      if (info.Length() == 3
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Effects::IVideoEffectDefinition^>(info[0])
        && info[1]->IsInt32())
      {
        try
        {
          ::Windows::Media::Effects::IVideoEffectDefinition^ arg0 = dynamic_cast<::Windows::Media::Effects::IVideoEffectDefinition^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Media::Capture::MediaStreamType arg1 = static_cast<::Windows::Media::Capture::MediaStreamType>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          op = wrapper->_instance->AddVideoEffectAsync(arg0,arg1);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.Media", "IMediaExtension", 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 PauseRecordAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

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


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

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

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


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

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

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


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


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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

      if (info.Length() == 3
        && info[0]->IsInt32()
        && NodeRT::Utils::IsGuid(info[1])
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[2]))
      {
        try
        {
          ::Windows::Media::Capture::MediaStreamType arg0 = static_cast<::Windows::Media::Capture::MediaStreamType>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          ::Platform::Guid arg1 = NodeRT::Utils::GuidFromJs(info[1]);
          ::Platform::Object^ arg2 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[2]));
          
          wrapper->_instance->SetEncoderProperty(arg0, arg1, arg2);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void GetEncoderProperty(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

      if (info.Length() == 2
        && info[0]->IsInt32()
        && NodeRT::Utils::IsGuid(info[1]))
      {
        try
        {
          ::Windows::Media::Capture::MediaStreamType arg0 = static_cast<::Windows::Media::Capture::MediaStreamType>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          ::Platform::Guid arg1 = NodeRT::Utils::GuidFromJs(info[1]);
          
          ::Platform::Object^ result;
          result = wrapper->_instance->GetEncoderProperty(arg0, arg1);
          info.GetReturnValue().Set(CreateOpaqueWrapper(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 SetPreviewMirroring(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsBoolean())
      {
        try
        {
          bool arg0 = Nan::To<bool>(info[0]).FromMaybe(false);
          
          wrapper->_instance->SetPreviewMirroring(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 GetPreviewMirroring(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::Media::Capture::VideoRotation arg0 = static_cast<::Windows::Media::Capture::VideoRotation>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          wrapper->_instance->SetPreviewRotation(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 GetPreviewRotation(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Media::Capture::VideoRotation result;
          result = wrapper->_instance->GetPreviewRotation();
          info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }
    static void SetRecordRotation(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::Media::Capture::VideoRotation arg0 = static_cast<::Windows::Media::Capture::VideoRotation>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          wrapper->_instance->SetRecordRotation(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 GetRecordRotation(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

      if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          bool result;
          result = ::Windows::Media::Capture::MediaCapture::IsVideoProfileSupported(arg0);
          info.GetReturnValue().Set(Nan::New<Boolean>(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

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

      if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          ::Windows::Foundation::Collections::IVectorView<::Windows::Media::Capture::MediaCaptureVideoProfile^>^ result;
          result = ::Windows::Media::Capture::MediaCapture::FindAllVideoProfiles(arg0);
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Media::Capture::MediaCaptureVideoProfile^>::CreateVectorViewWrapper(result, 
            [](::Windows::Media::Capture::MediaCaptureVideoProfile^ val) -> Local<Value> {
              return WrapMediaCaptureVideoProfile(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureVideoProfile^>(value);
            },
            [](Local<Value> value) -> ::Windows::Media::Capture::MediaCaptureVideoProfile^ {
              return UnwrapMediaCaptureVideoProfile(value);
            }
          ));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

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

      if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          ::Windows::Foundation::Collections::IVectorView<::Windows::Media::Capture::MediaCaptureVideoProfile^>^ result;
          result = ::Windows::Media::Capture::MediaCapture::FindConcurrentProfiles(arg0);
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Media::Capture::MediaCaptureVideoProfile^>::CreateVectorViewWrapper(result, 
            [](::Windows::Media::Capture::MediaCaptureVideoProfile^ val) -> Local<Value> {
              return WrapMediaCaptureVideoProfile(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureVideoProfile^>(value);
            },
            [](Local<Value> value) -> ::Windows::Media::Capture::MediaCaptureVideoProfile^ {
              return UnwrapMediaCaptureVideoProfile(value);
            }
          ));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

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

      if (info.Length() == 2
        && info[0]->IsString()
        && info[1]->IsInt32())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          ::Windows::Media::Capture::KnownVideoProfile arg1 = static_cast<::Windows::Media::Capture::KnownVideoProfile>(Nan::To<int32_t>(info[1]).FromMaybe(0));
          
          ::Windows::Foundation::Collections::IVectorView<::Windows::Media::Capture::MediaCaptureVideoProfile^>^ result;
          result = ::Windows::Media::Capture::MediaCapture::FindKnownVideoProfiles(arg0, arg1);
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Media::Capture::MediaCaptureVideoProfile^>::CreateVectorViewWrapper(result, 
            [](::Windows::Media::Capture::MediaCaptureVideoProfile^ val) -> Local<Value> {
              return WrapMediaCaptureVideoProfile(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureVideoProfile^>(value);
            },
            [](Local<Value> value) -> ::Windows::Media::Capture::MediaCaptureVideoProfile^ {
              return UnwrapMediaCaptureVideoProfile(value);
            }
          ));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IMapView<::Platform::String^, ::Windows::Media::Capture::Frames::MediaFrameSource^>^ result = wrapper->_instance->FrameSources;
        info.GetReturnValue().Set(NodeRT::Collections::MapViewWrapper<::Platform::String^,::Windows::Media::Capture::Frames::MediaFrameSource^>::CreateMapViewWrapper(result, 
            [](::Platform::String^ val) -> Local<Value> {
              return NodeRT::Utils::NewString(val->Data());
            },
            [](Local<Value> value) -> bool {
              return value->IsString();
            },
            [](Local<Value> value) -> ::Platform::String^ {
              return ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));
            },
            [](::Windows::Media::Capture::Frames::MediaFrameSource^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.Media.Capture.Frames", "MediaFrameSource", val);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


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

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

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

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

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"failed", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(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;
        }
        MediaCapture *wrapper = MediaCapture::Unwrap<MediaCapture>(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->Failed::add(
            ref new ::Windows::Media::Capture::MediaCaptureFailedEventHandler(
            [callbackObjPtr](::Windows::Media::Capture::MediaCapture^ arg0, ::Windows::Media::Capture::MediaCaptureFailedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapMediaCapture(arg0);
                  wrappedArg1 = WrapMediaCaptureFailedEventArgs(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"recordLimitationExceeded", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(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;
        }
        MediaCapture *wrapper = MediaCapture::Unwrap<MediaCapture>(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->RecordLimitationExceeded::add(
            ref new ::Windows::Media::Capture::RecordLimitationExceededEventHandler(
            [callbackObjPtr](::Windows::Media::Capture::MediaCapture^ arg0) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0]() {
                HandleScope scope;


                Local<Value> wrappedArg0;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapMediaCapture(arg0);


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

                Local<Value> args[] = { wrappedArg0 };
                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"focusChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(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;
        }
        MediaCapture *wrapper = MediaCapture::Unwrap<MediaCapture>(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->FocusChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::MediaCapture^, ::Windows::Media::Capture::MediaCaptureFocusChangedEventArgs^>(
            [callbackObjPtr](::Windows::Media::Capture::MediaCapture^ arg0, ::Windows::Media::Capture::MediaCaptureFocusChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapMediaCapture(arg0);
                  wrappedArg1 = WrapMediaCaptureFocusChangedEventArgs(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"photoConfirmationCaptured", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(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;
        }
        MediaCapture *wrapper = MediaCapture::Unwrap<MediaCapture>(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->PhotoConfirmationCaptured::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::MediaCapture^, ::Windows::Media::Capture::PhotoConfirmationCapturedEventArgs^>(
            [callbackObjPtr](::Windows::Media::Capture::MediaCapture^ arg0, ::Windows::Media::Capture::PhotoConfirmationCapturedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapMediaCapture(arg0);
                  wrappedArg1 = WrapPhotoConfirmationCapturedEventArgs(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"cameraStreamStateChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(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;
        }
        MediaCapture *wrapper = MediaCapture::Unwrap<MediaCapture>(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->CameraStreamStateChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::MediaCapture^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Media::Capture::MediaCapture^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapMediaCapture(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"thermalStatusChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(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;
        }
        MediaCapture *wrapper = MediaCapture::Unwrap<MediaCapture>(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->ThermalStatusChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::MediaCapture^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Media::Capture::MediaCapture^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapMediaCapture(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"captureDeviceExclusiveControlStatusChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(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;
        }
        MediaCapture *wrapper = MediaCapture::Unwrap<MediaCapture>(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->CaptureDeviceExclusiveControlStatusChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::MediaCapture^, ::Windows::Media::Capture::MediaCaptureDeviceExclusiveControlStatusChangedEventArgs^>(
            [callbackObjPtr](::Windows::Media::Capture::MediaCapture^ arg0, ::Windows::Media::Capture::MediaCaptureDeviceExclusiveControlStatusChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapMediaCapture(arg0);
                  wrappedArg1 = WrapMediaCaptureDeviceExclusiveControlStatusChangedEventArgs(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"failed", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"recordLimitationExceeded", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"focusChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"photoConfirmationCaptured", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"cameraStreamStateChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"thermalStatusChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"captureDeviceExclusiveControlStatusChanged", 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"failed", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(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;
          }
          MediaCapture *wrapper = MediaCapture::Unwrap<MediaCapture>(info.This());
          wrapper->_instance->Failed::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"recordLimitationExceeded", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(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;
          }
          MediaCapture *wrapper = MediaCapture::Unwrap<MediaCapture>(info.This());
          wrapper->_instance->RecordLimitationExceeded::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"focusChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(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;
          }
          MediaCapture *wrapper = MediaCapture::Unwrap<MediaCapture>(info.This());
          wrapper->_instance->FocusChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"photoConfirmationCaptured", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(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;
          }
          MediaCapture *wrapper = MediaCapture::Unwrap<MediaCapture>(info.This());
          wrapper->_instance->PhotoConfirmationCaptured::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"cameraStreamStateChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(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;
          }
          MediaCapture *wrapper = MediaCapture::Unwrap<MediaCapture>(info.This());
          wrapper->_instance->CameraStreamStateChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"thermalStatusChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(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;
          }
          MediaCapture *wrapper = MediaCapture::Unwrap<MediaCapture>(info.This());
          wrapper->_instance->ThermalStatusChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"captureDeviceExclusiveControlStatusChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(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;
          }
          MediaCapture *wrapper = MediaCapture::Unwrap<MediaCapture>(info.This());
          wrapper->_instance->CaptureDeviceExclusiveControlStatusChanged::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::Media::Capture::MediaCapture^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMediaCapture(::Windows::Media::Capture::MediaCapture^ wintRtInstance);
      friend ::Windows::Media::Capture::MediaCapture^ UnwrapMediaCapture(Local<Value> value);
  };

  Persistent<FunctionTemplate> MediaCapture::s_constructorTemplate;

  v8::Local<v8::Value> WrapMediaCapture(::Windows::Media::Capture::MediaCapture^ 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>(MediaCapture::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::MediaCapture^ UnwrapMediaCapture(Local<Value> value) {
     return MediaCapture::Unwrap<MediaCapture>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMediaCapture(Local<Object> exports) {
    MediaCapture::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("frameRate").ToLocalChecked(), FrameRateGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("height").ToLocalChecked(), HeightGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isHdrVideoSupported").ToLocalChecked(), IsHdrVideoSupportedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isVariablePhotoSequenceSupported").ToLocalChecked(), IsVariablePhotoSequenceSupportedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("width").ToLocalChecked(), WidthGetter);

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



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

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

    private:

      MediaCaptureVideoProfileMediaDescription(::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^ 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::Media::Capture::MediaCaptureVideoProfileMediaDescription^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMediaCaptureVideoProfileMediaDescription(::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^ wintRtInstance);
      friend ::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^ UnwrapMediaCaptureVideoProfileMediaDescription(Local<Value> value);
  };

  Persistent<FunctionTemplate> MediaCaptureVideoProfileMediaDescription::s_constructorTemplate;

  v8::Local<v8::Value> WrapMediaCaptureVideoProfileMediaDescription(::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^ 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>(MediaCaptureVideoProfileMediaDescription::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^ UnwrapMediaCaptureVideoProfileMediaDescription(Local<Value> value) {
     return MediaCaptureVideoProfileMediaDescription::Unwrap<MediaCaptureVideoProfileMediaDescription>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMediaCaptureVideoProfileMediaDescription(Local<Object> exports) {
    MediaCaptureVideoProfileMediaDescription::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "getConcurrency", GetConcurrency);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("id").ToLocalChecked(), IdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("supportedPhotoMediaDescription").ToLocalChecked(), SupportedPhotoMediaDescriptionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("supportedPreviewMediaDescription").ToLocalChecked(), SupportedPreviewMediaDescriptionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("supportedRecordMediaDescription").ToLocalChecked(), SupportedRecordMediaDescriptionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoDeviceId").ToLocalChecked(), VideoDeviceIdGetter);

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



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

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

    private:

      MediaCaptureVideoProfile(::Windows::Media::Capture::MediaCaptureVideoProfile^ 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::Media::Capture::MediaCaptureVideoProfile^ winRtInstance;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureVideoProfile^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Foundation::Collections::IVectorView<::Windows::Media::Capture::MediaCaptureVideoProfile^>^ result;
          result = wrapper->_instance->GetConcurrency();
          info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Media::Capture::MediaCaptureVideoProfile^>::CreateVectorViewWrapper(result, 
            [](::Windows::Media::Capture::MediaCaptureVideoProfile^ val) -> Local<Value> {
              return WrapMediaCaptureVideoProfile(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureVideoProfile^>(value);
            },
            [](Local<Value> value) -> ::Windows::Media::Capture::MediaCaptureVideoProfile^ {
              return UnwrapMediaCaptureVideoProfile(value);
            }
          ));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureVideoProfile^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureVideoProfile^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^>^ result = wrapper->_instance->SupportedPhotoMediaDescription;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^>::CreateVectorViewWrapper(result, 
            [](::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^ val) -> Local<Value> {
              return WrapMediaCaptureVideoProfileMediaDescription(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^>(value);
            },
            [](Local<Value> value) -> ::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^ {
              return UnwrapMediaCaptureVideoProfileMediaDescription(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SupportedPreviewMediaDescriptionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureVideoProfile^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^>^ result = wrapper->_instance->SupportedPreviewMediaDescription;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^>::CreateVectorViewWrapper(result, 
            [](::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^ val) -> Local<Value> {
              return WrapMediaCaptureVideoProfileMediaDescription(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^>(value);
            },
            [](Local<Value> value) -> ::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^ {
              return UnwrapMediaCaptureVideoProfileMediaDescription(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SupportedRecordMediaDescriptionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureVideoProfile^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^>^ result = wrapper->_instance->SupportedRecordMediaDescription;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^>::CreateVectorViewWrapper(result, 
            [](::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^ val) -> Local<Value> {
              return WrapMediaCaptureVideoProfileMediaDescription(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^>(value);
            },
            [](Local<Value> value) -> ::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^ {
              return UnwrapMediaCaptureVideoProfileMediaDescription(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VideoDeviceIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureVideoProfile^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Media::Capture::MediaCaptureVideoProfile^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMediaCaptureVideoProfile(::Windows::Media::Capture::MediaCaptureVideoProfile^ wintRtInstance);
      friend ::Windows::Media::Capture::MediaCaptureVideoProfile^ UnwrapMediaCaptureVideoProfile(Local<Value> value);
  };

  Persistent<FunctionTemplate> MediaCaptureVideoProfile::s_constructorTemplate;

  v8::Local<v8::Value> WrapMediaCaptureVideoProfile(::Windows::Media::Capture::MediaCaptureVideoProfile^ 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>(MediaCaptureVideoProfile::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::MediaCaptureVideoProfile^ UnwrapMediaCaptureVideoProfile(Local<Value> value) {
     return MediaCaptureVideoProfile::Unwrap<MediaCaptureVideoProfile>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMediaCaptureVideoProfile(Local<Object> exports) {
    MediaCaptureVideoProfile::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoDeviceId").ToLocalChecked(), VideoDeviceIdGetter, VideoDeviceIdSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("audioDeviceId").ToLocalChecked(), AudioDeviceIdGetter, AudioDeviceIdSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("photoCaptureSource").ToLocalChecked(), PhotoCaptureSourceGetter, PhotoCaptureSourceSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("streamingCaptureMode").ToLocalChecked(), StreamingCaptureModeGetter, StreamingCaptureModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("mediaCategory").ToLocalChecked(), MediaCategoryGetter, MediaCategorySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("audioProcessing").ToLocalChecked(), AudioProcessingGetter, AudioProcessingSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoSource").ToLocalChecked(), VideoSourceGetter, VideoSourceSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("audioSource").ToLocalChecked(), AudioSourceGetter, AudioSourceSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("recordMediaDescription").ToLocalChecked(), RecordMediaDescriptionGetter, RecordMediaDescriptionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoProfile").ToLocalChecked(), VideoProfileGetter, VideoProfileSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("photoMediaDescription").ToLocalChecked(), PhotoMediaDescriptionGetter, PhotoMediaDescriptionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("previewMediaDescription").ToLocalChecked(), PreviewMediaDescriptionGetter, PreviewMediaDescriptionSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("sourceGroup").ToLocalChecked(), SourceGroupGetter, SourceGroupSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("sharingMode").ToLocalChecked(), SharingModeGetter, SharingModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("memoryPreference").ToLocalChecked(), MemoryPreferenceGetter, MemoryPreferenceSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("alwaysPlaySystemShutterSound").ToLocalChecked(), AlwaysPlaySystemShutterSoundGetter, AlwaysPlaySystemShutterSoundSetter);

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



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

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

    private:

      MediaCaptureInitializationSettings(::Windows::Media::Capture::MediaCaptureInitializationSettings^ 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::Media::Capture::MediaCaptureInitializationSettings^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureInitializationSettings^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureInitializationSettings^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureInitializationSettings^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureInitializationSettings^>(info.This())) {
        return;
      }

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureInitializationSettings^>(info.This())) {
        return;
      }

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

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

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

      try {

        ::Windows::Media::Capture::PhotoCaptureSource winRtValue = static_cast<::Windows::Media::Capture::PhotoCaptureSource>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureInitializationSettings^>(info.This())) {
        return;
      }

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

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

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

      try {

        ::Windows::Media::Capture::StreamingCaptureMode winRtValue = static_cast<::Windows::Media::Capture::StreamingCaptureMode>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureInitializationSettings^>(info.This())) {
        return;
      }

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

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

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

      try {

        ::Windows::Media::Capture::MediaCategory winRtValue = static_cast<::Windows::Media::Capture::MediaCategory>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureInitializationSettings^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureInitializationSettings^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureInitializationSettings^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Media::Core::IMediaSource^ winRtValue = dynamic_cast<::Windows::Media::Core::IMediaSource^>(NodeRT::Utils::GetObjectInstance(value));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureInitializationSettings^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureInitializationSettings^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Media::Core::IMediaSource^ winRtValue = dynamic_cast<::Windows::Media::Core::IMediaSource^>(NodeRT::Utils::GetObjectInstance(value));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureInitializationSettings^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^ result = wrapper->_instance->RecordMediaDescription;
        info.GetReturnValue().Set(WrapMediaCaptureVideoProfileMediaDescription(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RecordMediaDescriptionSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureInitializationSettings^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^ winRtValue = dynamic_cast<::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^>(NodeRT::Utils::GetObjectInstance(value));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureInitializationSettings^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Media::Capture::MediaCaptureVideoProfile^ result = wrapper->_instance->VideoProfile;
        info.GetReturnValue().Set(WrapMediaCaptureVideoProfile(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VideoProfileSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureInitializationSettings^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Media::Capture::MediaCaptureVideoProfile^ winRtValue = dynamic_cast<::Windows::Media::Capture::MediaCaptureVideoProfile^>(NodeRT::Utils::GetObjectInstance(value));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureInitializationSettings^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^ result = wrapper->_instance->PhotoMediaDescription;
        info.GetReturnValue().Set(WrapMediaCaptureVideoProfileMediaDescription(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PhotoMediaDescriptionSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureInitializationSettings^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^ winRtValue = dynamic_cast<::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^>(NodeRT::Utils::GetObjectInstance(value));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureInitializationSettings^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^ result = wrapper->_instance->PreviewMediaDescription;
        info.GetReturnValue().Set(WrapMediaCaptureVideoProfileMediaDescription(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PreviewMediaDescriptionSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureInitializationSettings^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^ winRtValue = dynamic_cast<::Windows::Media::Capture::MediaCaptureVideoProfileMediaDescription^>(NodeRT::Utils::GetObjectInstance(value));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureInitializationSettings^>(info.This())) {
        return;
      }

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureInitializationSettings^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Media::Capture::Frames::MediaFrameSourceGroup^ winRtValue = dynamic_cast<::Windows::Media::Capture::Frames::MediaFrameSourceGroup^>(NodeRT::Utils::GetObjectInstance(value));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureInitializationSettings^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Media::Capture::MediaCaptureSharingMode result = wrapper->_instance->SharingMode;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SharingModeSetter(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::Media::Capture::MediaCaptureInitializationSettings^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Media::Capture::MediaCaptureSharingMode winRtValue = static_cast<::Windows::Media::Capture::MediaCaptureSharingMode>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureInitializationSettings^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Media::Capture::MediaCaptureMemoryPreference result = wrapper->_instance->MemoryPreference;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MemoryPreferenceSetter(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::Media::Capture::MediaCaptureInitializationSettings^>(info.This())) {
        return;
      }

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

      try {

        ::Windows::Media::Capture::MediaCaptureMemoryPreference winRtValue = static_cast<::Windows::Media::Capture::MediaCaptureMemoryPreference>(Nan::To<int32_t>(value).FromMaybe(0));

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureInitializationSettings^>(info.This())) {
        return;
      }

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

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

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

      try {

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

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


    private:
      ::Windows::Media::Capture::MediaCaptureInitializationSettings^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMediaCaptureInitializationSettings(::Windows::Media::Capture::MediaCaptureInitializationSettings^ wintRtInstance);
      friend ::Windows::Media::Capture::MediaCaptureInitializationSettings^ UnwrapMediaCaptureInitializationSettings(Local<Value> value);
  };

  Persistent<FunctionTemplate> MediaCaptureInitializationSettings::s_constructorTemplate;

  v8::Local<v8::Value> WrapMediaCaptureInitializationSettings(::Windows::Media::Capture::MediaCaptureInitializationSettings^ 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>(MediaCaptureInitializationSettings::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::MediaCaptureInitializationSettings^ UnwrapMediaCaptureInitializationSettings(Local<Value> value) {
     return MediaCaptureInitializationSettings::Unwrap<MediaCaptureInitializationSettings>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMediaCaptureInitializationSettings(Local<Object> exports) {
    MediaCaptureInitializationSettings::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("audioDeviceId").ToLocalChecked(), AudioDeviceIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("photoCaptureSource").ToLocalChecked(), PhotoCaptureSourceGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("streamingCaptureMode").ToLocalChecked(), StreamingCaptureModeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoDeviceCharacteristic").ToLocalChecked(), VideoDeviceCharacteristicGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoDeviceId").ToLocalChecked(), VideoDeviceIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("audioProcessing").ToLocalChecked(), AudioProcessingGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("cameraSoundRequiredForRegion").ToLocalChecked(), CameraSoundRequiredForRegionGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("concurrentRecordAndPhotoSequenceSupported").ToLocalChecked(), ConcurrentRecordAndPhotoSequenceSupportedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("concurrentRecordAndPhotoSupported").ToLocalChecked(), ConcurrentRecordAndPhotoSupportedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("horizontal35mmEquivalentFocalLength").ToLocalChecked(), Horizontal35mmEquivalentFocalLengthGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("mediaCategory").ToLocalChecked(), MediaCategoryGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("pitchOffsetDegrees").ToLocalChecked(), PitchOffsetDegreesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("vertical35mmEquivalentFocalLength").ToLocalChecked(), Vertical35mmEquivalentFocalLengthGetter);

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



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

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

    private:

      MediaCaptureSettings(::Windows::Media::Capture::MediaCaptureSettings^ 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::Media::Capture::MediaCaptureSettings^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureSettings^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureSettings^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureSettings^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureSettings^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureSettings^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureSettings^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureSettings^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureSettings^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureSettings^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureSettings^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureSettings^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureSettings^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureSettings^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Media::Capture::MediaCaptureSettings^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMediaCaptureSettings(::Windows::Media::Capture::MediaCaptureSettings^ wintRtInstance);
      friend ::Windows::Media::Capture::MediaCaptureSettings^ UnwrapMediaCaptureSettings(Local<Value> value);
  };

  Persistent<FunctionTemplate> MediaCaptureSettings::s_constructorTemplate;

  v8::Local<v8::Value> WrapMediaCaptureSettings(::Windows::Media::Capture::MediaCaptureSettings^ 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>(MediaCaptureSettings::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::MediaCaptureSettings^ UnwrapMediaCaptureSettings(Local<Value> value) {
     return MediaCaptureSettings::Unwrap<MediaCaptureSettings>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMediaCaptureSettings(Local<Object> exports) {
    MediaCaptureSettings::Init(exports);
  }

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

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


          
            Nan::SetPrototypeMethod(localRef, "startAsync", StartAsync);
            Nan::SetPrototypeMethod(localRef, "stopAsync", StopAsync);
            Nan::SetPrototypeMethod(localRef, "finishAsync", FinishAsync);
            Nan::SetPrototypeMethod(localRef, "pauseAsync", PauseAsync);
            Nan::SetPrototypeMethod(localRef, "resumeAsync", ResumeAsync);
            Nan::SetPrototypeMethod(localRef, "pauseWithResultAsync", PauseWithResultAsync);
            Nan::SetPrototypeMethod(localRef, "stopWithResultAsync", StopWithResultAsync);
          



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



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

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

    private:

      LowLagMediaRecording(::Windows::Media::Capture::LowLagMediaRecording^ 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::Media::Capture::LowLagMediaRecording^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::LowLagMediaRecording^>(info.This())) {
        return;
      }

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

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

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


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

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::LowLagMediaRecording^>(info.This())) {
        return;
      }

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

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

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


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

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::LowLagMediaRecording^>(info.This())) {
        return;
      }

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

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

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


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

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::LowLagMediaRecording^>(info.This())) {
        return;
      }

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

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

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


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

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::LowLagMediaRecording^>(info.This())) {
        return;
      }

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

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

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


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

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::LowLagMediaRecording^>(info.This())) {
        return;
      }

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Media::Capture::MediaCapturePauseResult^>^ op;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::LowLagMediaRecording^>(info.This())) {
        return;
      }

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Media::Capture::MediaCaptureStopResult^>^ op;


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

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

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


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


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

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






    private:
      ::Windows::Media::Capture::LowLagMediaRecording^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapLowLagMediaRecording(::Windows::Media::Capture::LowLagMediaRecording^ wintRtInstance);
      friend ::Windows::Media::Capture::LowLagMediaRecording^ UnwrapLowLagMediaRecording(Local<Value> value);
  };

  Persistent<FunctionTemplate> LowLagMediaRecording::s_constructorTemplate;

  v8::Local<v8::Value> WrapLowLagMediaRecording(::Windows::Media::Capture::LowLagMediaRecording^ 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>(LowLagMediaRecording::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::LowLagMediaRecording^ UnwrapLowLagMediaRecording(Local<Value> value) {
     return LowLagMediaRecording::Unwrap<LowLagMediaRecording>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitLowLagMediaRecording(Local<Object> exports) {
    LowLagMediaRecording::Init(exports);
  }

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

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


          
            Nan::SetPrototypeMethod(localRef, "captureAsync", CaptureAsync);
            Nan::SetPrototypeMethod(localRef, "finishAsync", FinishAsync);
          



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



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

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

    private:

      LowLagPhotoCapture(::Windows::Media::Capture::LowLagPhotoCapture^ 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::Media::Capture::LowLagPhotoCapture^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::LowLagPhotoCapture^>(info.This())) {
        return;
      }

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Media::Capture::CapturedPhoto^>^ op;


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

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::LowLagPhotoCapture^>(info.This())) {
        return;
      }

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

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

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


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

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

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


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


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

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






    private:
      ::Windows::Media::Capture::LowLagPhotoCapture^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapLowLagPhotoCapture(::Windows::Media::Capture::LowLagPhotoCapture^ wintRtInstance);
      friend ::Windows::Media::Capture::LowLagPhotoCapture^ UnwrapLowLagPhotoCapture(Local<Value> value);
  };

  Persistent<FunctionTemplate> LowLagPhotoCapture::s_constructorTemplate;

  v8::Local<v8::Value> WrapLowLagPhotoCapture(::Windows::Media::Capture::LowLagPhotoCapture^ 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>(LowLagPhotoCapture::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::LowLagPhotoCapture^ UnwrapLowLagPhotoCapture(Local<Value> value) {
     return LowLagPhotoCapture::Unwrap<LowLagPhotoCapture>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitLowLagPhotoCapture(Local<Object> exports) {
    LowLagPhotoCapture::Init(exports);
  }

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

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


          
            Nan::SetPrototypeMethod(localRef, "startAsync", StartAsync);
            Nan::SetPrototypeMethod(localRef, "stopAsync", StopAsync);
            Nan::SetPrototypeMethod(localRef, "finishAsync", FinishAsync);
          

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


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



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

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

    private:

      LowLagPhotoSequenceCapture(::Windows::Media::Capture::LowLagPhotoSequenceCapture^ 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::Media::Capture::LowLagPhotoSequenceCapture^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::LowLagPhotoSequenceCapture^>(info.This())) {
        return;
      }

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

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

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


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

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::LowLagPhotoSequenceCapture^>(info.This())) {
        return;
      }

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

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

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


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

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

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


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


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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::LowLagPhotoSequenceCapture^>(info.This())) {
        return;
      }

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

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

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


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

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

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


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


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

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






    static void 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"photoCaptured", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::LowLagPhotoSequenceCapture^>(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;
        }
        LowLagPhotoSequenceCapture *wrapper = LowLagPhotoSequenceCapture::Unwrap<LowLagPhotoSequenceCapture>(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->PhotoCaptured::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::LowLagPhotoSequenceCapture^, ::Windows::Media::Capture::PhotoCapturedEventArgs^>(
            [callbackObjPtr](::Windows::Media::Capture::LowLagPhotoSequenceCapture^ arg0, ::Windows::Media::Capture::PhotoCapturedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapLowLagPhotoSequenceCapture(arg0);
                  wrappedArg1 = WrapPhotoCapturedEventArgs(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"photoCaptured", 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"photoCaptured", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::LowLagPhotoSequenceCapture^>(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;
          }
          LowLagPhotoSequenceCapture *wrapper = LowLagPhotoSequenceCapture::Unwrap<LowLagPhotoSequenceCapture>(info.This());
          wrapper->_instance->PhotoCaptured::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::Media::Capture::LowLagPhotoSequenceCapture^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapLowLagPhotoSequenceCapture(::Windows::Media::Capture::LowLagPhotoSequenceCapture^ wintRtInstance);
      friend ::Windows::Media::Capture::LowLagPhotoSequenceCapture^ UnwrapLowLagPhotoSequenceCapture(Local<Value> value);
  };

  Persistent<FunctionTemplate> LowLagPhotoSequenceCapture::s_constructorTemplate;

  v8::Local<v8::Value> WrapLowLagPhotoSequenceCapture(::Windows::Media::Capture::LowLagPhotoSequenceCapture^ 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>(LowLagPhotoSequenceCapture::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::LowLagPhotoSequenceCapture^ UnwrapLowLagPhotoSequenceCapture(Local<Value> value) {
     return LowLagPhotoSequenceCapture::Unwrap<LowLagPhotoSequenceCapture>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitLowLagPhotoSequenceCapture(Local<Object> exports) {
    LowLagPhotoSequenceCapture::Init(exports);
  }

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





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

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



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

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

    private:

      MediaCaptureFocusChangedEventArgs(::Windows::Media::Capture::MediaCaptureFocusChangedEventArgs^ 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::Media::Capture::MediaCaptureFocusChangedEventArgs^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureFocusChangedEventArgs^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Media::Capture::MediaCaptureFocusChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMediaCaptureFocusChangedEventArgs(::Windows::Media::Capture::MediaCaptureFocusChangedEventArgs^ wintRtInstance);
      friend ::Windows::Media::Capture::MediaCaptureFocusChangedEventArgs^ UnwrapMediaCaptureFocusChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> MediaCaptureFocusChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapMediaCaptureFocusChangedEventArgs(::Windows::Media::Capture::MediaCaptureFocusChangedEventArgs^ 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>(MediaCaptureFocusChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::MediaCaptureFocusChangedEventArgs^ UnwrapMediaCaptureFocusChangedEventArgs(Local<Value> value) {
     return MediaCaptureFocusChangedEventArgs::Unwrap<MediaCaptureFocusChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMediaCaptureFocusChangedEventArgs(Local<Object> exports) {
    MediaCaptureFocusChangedEventArgs::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("captureTimeOffset").ToLocalChecked(), CaptureTimeOffsetGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("frame").ToLocalChecked(), FrameGetter);

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



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

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

    private:

      PhotoConfirmationCapturedEventArgs(::Windows::Media::Capture::PhotoConfirmationCapturedEventArgs^ 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::Media::Capture::PhotoConfirmationCapturedEventArgs^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::PhotoConfirmationCapturedEventArgs^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::PhotoConfirmationCapturedEventArgs^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Media::Capture::CapturedFrame^ result = wrapper->_instance->Frame;
        info.GetReturnValue().Set(WrapCapturedFrame(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::PhotoConfirmationCapturedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPhotoConfirmationCapturedEventArgs(::Windows::Media::Capture::PhotoConfirmationCapturedEventArgs^ wintRtInstance);
      friend ::Windows::Media::Capture::PhotoConfirmationCapturedEventArgs^ UnwrapPhotoConfirmationCapturedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> PhotoConfirmationCapturedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapPhotoConfirmationCapturedEventArgs(::Windows::Media::Capture::PhotoConfirmationCapturedEventArgs^ 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>(PhotoConfirmationCapturedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::PhotoConfirmationCapturedEventArgs^ UnwrapPhotoConfirmationCapturedEventArgs(Local<Value> value) {
     return PhotoConfirmationCapturedEventArgs::Unwrap<PhotoConfirmationCapturedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPhotoConfirmationCapturedEventArgs(Local<Object> exports) {
    PhotoConfirmationCapturedEventArgs::Init(exports);
  }

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

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


          
            Nan::SetPrototypeMethod(localRef, "captureAsync", CaptureAsync);
            Nan::SetPrototypeMethod(localRef, "finishAsync", FinishAsync);
          

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


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



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

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

    private:

      AdvancedPhotoCapture(::Windows::Media::Capture::AdvancedPhotoCapture^ 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::Media::Capture::AdvancedPhotoCapture^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AdvancedPhotoCapture^>(info.This())) {
        return;
      }

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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Media::Capture::AdvancedCapturedPhoto^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->CaptureAsync();
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Platform::Object^>(info[0]))
      {
        try
        {
          ::Platform::Object^ arg0 = dynamic_cast<::Platform::Object^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          op = wrapper->_instance->CaptureAsync(arg0);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

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

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


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AdvancedPhotoCapture^>(info.This())) {
        return;
      }

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

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

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


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

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

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


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


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

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






    static void 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"allPhotosCaptured", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AdvancedPhotoCapture^>(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;
        }
        AdvancedPhotoCapture *wrapper = AdvancedPhotoCapture::Unwrap<AdvancedPhotoCapture>(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->AllPhotosCaptured::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::AdvancedPhotoCapture^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Media::Capture::AdvancedPhotoCapture^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAdvancedPhotoCapture(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"optionalReferencePhotoCaptured", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AdvancedPhotoCapture^>(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;
        }
        AdvancedPhotoCapture *wrapper = AdvancedPhotoCapture::Unwrap<AdvancedPhotoCapture>(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->OptionalReferencePhotoCaptured::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::AdvancedPhotoCapture^, ::Windows::Media::Capture::OptionalReferencePhotoCapturedEventArgs^>(
            [callbackObjPtr](::Windows::Media::Capture::AdvancedPhotoCapture^ arg0, ::Windows::Media::Capture::OptionalReferencePhotoCapturedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


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

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAdvancedPhotoCapture(arg0);
                  wrappedArg1 = WrapOptionalReferencePhotoCapturedEventArgs(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"allPhotosCaptured", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"optionalReferencePhotoCaptured", 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"allPhotosCaptured", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AdvancedPhotoCapture^>(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;
          }
          AdvancedPhotoCapture *wrapper = AdvancedPhotoCapture::Unwrap<AdvancedPhotoCapture>(info.This());
          wrapper->_instance->AllPhotosCaptured::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"optionalReferencePhotoCaptured", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AdvancedPhotoCapture^>(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;
          }
          AdvancedPhotoCapture *wrapper = AdvancedPhotoCapture::Unwrap<AdvancedPhotoCapture>(info.This());
          wrapper->_instance->OptionalReferencePhotoCaptured::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::Media::Capture::AdvancedPhotoCapture^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAdvancedPhotoCapture(::Windows::Media::Capture::AdvancedPhotoCapture^ wintRtInstance);
      friend ::Windows::Media::Capture::AdvancedPhotoCapture^ UnwrapAdvancedPhotoCapture(Local<Value> value);
  };

  Persistent<FunctionTemplate> AdvancedPhotoCapture::s_constructorTemplate;

  v8::Local<v8::Value> WrapAdvancedPhotoCapture(::Windows::Media::Capture::AdvancedPhotoCapture^ 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>(AdvancedPhotoCapture::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AdvancedPhotoCapture^ UnwrapAdvancedPhotoCapture(Local<Value> value) {
     return AdvancedPhotoCapture::Unwrap<AdvancedPhotoCapture>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAdvancedPhotoCapture(Local<Object> exports) {
    AdvancedPhotoCapture::Init(exports);
  }

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


          
            Nan::SetPrototypeMethod(localRef, "close", Close);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("lastFrame").ToLocalChecked(), LastFrameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("recordDuration").ToLocalChecked(), RecordDurationGetter);

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



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

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

    private:

      MediaCapturePauseResult(::Windows::Media::Capture::MediaCapturePauseResult^ 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::Media::Capture::MediaCapturePauseResult^ winRtInstance;


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

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

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



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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapturePauseResult^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0) {
        try {
          delete wrapper->_instance;
          wrapper->_instance = nullptr;
          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 LastFrameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapturePauseResult^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Media::VideoFrame^ result = wrapper->_instance->LastFrame;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Media", "VideoFrame", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RecordDurationGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapturePauseResult^>(info.This())) {
        return;
      }

      MediaCapturePauseResult *wrapper = MediaCapturePauseResult::Unwrap<MediaCapturePauseResult>(info.This());

      try  {
        ::Windows::Foundation::TimeSpan result = wrapper->_instance->RecordDuration;
        info.GetReturnValue().Set(Nan::New<Number>(result.Duration/10000.0));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::MediaCapturePauseResult^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMediaCapturePauseResult(::Windows::Media::Capture::MediaCapturePauseResult^ wintRtInstance);
      friend ::Windows::Media::Capture::MediaCapturePauseResult^ UnwrapMediaCapturePauseResult(Local<Value> value);
  };

  Persistent<FunctionTemplate> MediaCapturePauseResult::s_constructorTemplate;

  v8::Local<v8::Value> WrapMediaCapturePauseResult(::Windows::Media::Capture::MediaCapturePauseResult^ 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>(MediaCapturePauseResult::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::MediaCapturePauseResult^ UnwrapMediaCapturePauseResult(Local<Value> value) {
     return MediaCapturePauseResult::Unwrap<MediaCapturePauseResult>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMediaCapturePauseResult(Local<Object> exports) {
    MediaCapturePauseResult::Init(exports);
  }

  class MediaCaptureStopResult : 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>("MediaCaptureStopResult").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "close", Close);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("lastFrame").ToLocalChecked(), LastFrameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("recordDuration").ToLocalChecked(), RecordDurationGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("MediaCaptureStopResult").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      MediaCaptureStopResult(::Windows::Media::Capture::MediaCaptureStopResult^ 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::Media::Capture::MediaCaptureStopResult^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureStopResult^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::MediaCaptureStopResult^) 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());

      MediaCaptureStopResult *wrapperInstance = new MediaCaptureStopResult(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::Media::Capture::MediaCaptureStopResult^>(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::Media::Capture::MediaCaptureStopResult^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::MediaCaptureStopResult^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapMediaCaptureStopResult(winRtInstance));
    }



    static void Close(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureStopResult^>(info.This())) {
        return;
      }

      MediaCaptureStopResult *wrapper = MediaCaptureStopResult::Unwrap<MediaCaptureStopResult>(info.This());

      if (info.Length() == 0) {
        try {
          delete wrapper->_instance;
          wrapper->_instance = nullptr;
          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 LastFrameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureStopResult^>(info.This())) {
        return;
      }

      MediaCaptureStopResult *wrapper = MediaCaptureStopResult::Unwrap<MediaCaptureStopResult>(info.This());

      try  {
        ::Windows::Media::VideoFrame^ result = wrapper->_instance->LastFrame;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Media", "VideoFrame", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RecordDurationGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureStopResult^>(info.This())) {
        return;
      }

      MediaCaptureStopResult *wrapper = MediaCaptureStopResult::Unwrap<MediaCaptureStopResult>(info.This());

      try  {
        ::Windows::Foundation::TimeSpan result = wrapper->_instance->RecordDuration;
        info.GetReturnValue().Set(Nan::New<Number>(result.Duration/10000.0));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::MediaCaptureStopResult^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMediaCaptureStopResult(::Windows::Media::Capture::MediaCaptureStopResult^ wintRtInstance);
      friend ::Windows::Media::Capture::MediaCaptureStopResult^ UnwrapMediaCaptureStopResult(Local<Value> value);
  };

  Persistent<FunctionTemplate> MediaCaptureStopResult::s_constructorTemplate;

  v8::Local<v8::Value> WrapMediaCaptureStopResult(::Windows::Media::Capture::MediaCaptureStopResult^ 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>(MediaCaptureStopResult::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::MediaCaptureStopResult^ UnwrapMediaCaptureStopResult(Local<Value> value) {
     return MediaCaptureStopResult::Unwrap<MediaCaptureStopResult>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMediaCaptureStopResult(Local<Object> exports) {
    MediaCaptureStopResult::Init(exports);
  }

  class MediaCaptureDeviceExclusiveControlStatusChangedEventArgs : 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>("MediaCaptureDeviceExclusiveControlStatusChangedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("deviceId").ToLocalChecked(), DeviceIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("status").ToLocalChecked(), StatusGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("MediaCaptureDeviceExclusiveControlStatusChangedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      MediaCaptureDeviceExclusiveControlStatusChangedEventArgs(::Windows::Media::Capture::MediaCaptureDeviceExclusiveControlStatusChangedEventArgs^ 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::Media::Capture::MediaCaptureDeviceExclusiveControlStatusChangedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureDeviceExclusiveControlStatusChangedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::MediaCaptureDeviceExclusiveControlStatusChangedEventArgs^) 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());

      MediaCaptureDeviceExclusiveControlStatusChangedEventArgs *wrapperInstance = new MediaCaptureDeviceExclusiveControlStatusChangedEventArgs(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::Media::Capture::MediaCaptureDeviceExclusiveControlStatusChangedEventArgs^>(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::Media::Capture::MediaCaptureDeviceExclusiveControlStatusChangedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::MediaCaptureDeviceExclusiveControlStatusChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapMediaCaptureDeviceExclusiveControlStatusChangedEventArgs(winRtInstance));
    }





    static void DeviceIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureDeviceExclusiveControlStatusChangedEventArgs^>(info.This())) {
        return;
      }

      MediaCaptureDeviceExclusiveControlStatusChangedEventArgs *wrapper = MediaCaptureDeviceExclusiveControlStatusChangedEventArgs::Unwrap<MediaCaptureDeviceExclusiveControlStatusChangedEventArgs>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->DeviceId;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void StatusGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCaptureDeviceExclusiveControlStatusChangedEventArgs^>(info.This())) {
        return;
      }

      MediaCaptureDeviceExclusiveControlStatusChangedEventArgs *wrapper = MediaCaptureDeviceExclusiveControlStatusChangedEventArgs::Unwrap<MediaCaptureDeviceExclusiveControlStatusChangedEventArgs>(info.This());

      try  {
        ::Windows::Media::Capture::MediaCaptureDeviceExclusiveControlStatus result = wrapper->_instance->Status;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::MediaCaptureDeviceExclusiveControlStatusChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapMediaCaptureDeviceExclusiveControlStatusChangedEventArgs(::Windows::Media::Capture::MediaCaptureDeviceExclusiveControlStatusChangedEventArgs^ wintRtInstance);
      friend ::Windows::Media::Capture::MediaCaptureDeviceExclusiveControlStatusChangedEventArgs^ UnwrapMediaCaptureDeviceExclusiveControlStatusChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> MediaCaptureDeviceExclusiveControlStatusChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapMediaCaptureDeviceExclusiveControlStatusChangedEventArgs(::Windows::Media::Capture::MediaCaptureDeviceExclusiveControlStatusChangedEventArgs^ 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>(MediaCaptureDeviceExclusiveControlStatusChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::MediaCaptureDeviceExclusiveControlStatusChangedEventArgs^ UnwrapMediaCaptureDeviceExclusiveControlStatusChangedEventArgs(Local<Value> value) {
     return MediaCaptureDeviceExclusiveControlStatusChangedEventArgs::Unwrap<MediaCaptureDeviceExclusiveControlStatusChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitMediaCaptureDeviceExclusiveControlStatusChangedEventArgs(Local<Object> exports) {
    MediaCaptureDeviceExclusiveControlStatusChangedEventArgs::Init(exports);
  }

  class CapturedPhoto : 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>("CapturedPhoto").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("frame").ToLocalChecked(), FrameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("thumbnail").ToLocalChecked(), ThumbnailGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("CapturedPhoto").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      CapturedPhoto(::Windows::Media::Capture::CapturedPhoto^ 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::Media::Capture::CapturedPhoto^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedPhoto^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::CapturedPhoto^) 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());

      CapturedPhoto *wrapperInstance = new CapturedPhoto(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::Media::Capture::CapturedPhoto^>(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::Media::Capture::CapturedPhoto^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::CapturedPhoto^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapCapturedPhoto(winRtInstance));
    }





    static void FrameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedPhoto^>(info.This())) {
        return;
      }

      CapturedPhoto *wrapper = CapturedPhoto::Unwrap<CapturedPhoto>(info.This());

      try  {
        ::Windows::Media::Capture::CapturedFrame^ result = wrapper->_instance->Frame;
        info.GetReturnValue().Set(WrapCapturedFrame(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ThumbnailGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedPhoto^>(info.This())) {
        return;
      }

      CapturedPhoto *wrapper = CapturedPhoto::Unwrap<CapturedPhoto>(info.This());

      try  {
        ::Windows::Media::Capture::CapturedFrame^ result = wrapper->_instance->Thumbnail;
        info.GetReturnValue().Set(WrapCapturedFrame(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::CapturedPhoto^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapCapturedPhoto(::Windows::Media::Capture::CapturedPhoto^ wintRtInstance);
      friend ::Windows::Media::Capture::CapturedPhoto^ UnwrapCapturedPhoto(Local<Value> value);
  };

  Persistent<FunctionTemplate> CapturedPhoto::s_constructorTemplate;

  v8::Local<v8::Value> WrapCapturedPhoto(::Windows::Media::Capture::CapturedPhoto^ 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>(CapturedPhoto::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::CapturedPhoto^ UnwrapCapturedPhoto(Local<Value> value) {
     return CapturedPhoto::Unwrap<CapturedPhoto>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitCapturedPhoto(Local<Object> exports) {
    CapturedPhoto::Init(exports);
  }

  class AdvancedCapturedPhoto : 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>("AdvancedCapturedPhoto").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("context").ToLocalChecked(), ContextGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("frame").ToLocalChecked(), FrameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("mode").ToLocalChecked(), ModeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("frameBoundsRelativeToReferencePhoto").ToLocalChecked(), FrameBoundsRelativeToReferencePhotoGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AdvancedCapturedPhoto").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AdvancedCapturedPhoto(::Windows::Media::Capture::AdvancedCapturedPhoto^ 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::Media::Capture::AdvancedCapturedPhoto^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AdvancedCapturedPhoto^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AdvancedCapturedPhoto^) 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());

      AdvancedCapturedPhoto *wrapperInstance = new AdvancedCapturedPhoto(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::Media::Capture::AdvancedCapturedPhoto^>(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::Media::Capture::AdvancedCapturedPhoto^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AdvancedCapturedPhoto^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAdvancedCapturedPhoto(winRtInstance));
    }





    static void ContextGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AdvancedCapturedPhoto^>(info.This())) {
        return;
      }

      AdvancedCapturedPhoto *wrapper = AdvancedCapturedPhoto::Unwrap<AdvancedCapturedPhoto>(info.This());

      try  {
        ::Platform::Object^ result = wrapper->_instance->Context;
        info.GetReturnValue().Set(CreateOpaqueWrapper(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void FrameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AdvancedCapturedPhoto^>(info.This())) {
        return;
      }

      AdvancedCapturedPhoto *wrapper = AdvancedCapturedPhoto::Unwrap<AdvancedCapturedPhoto>(info.This());

      try  {
        ::Windows::Media::Capture::CapturedFrame^ result = wrapper->_instance->Frame;
        info.GetReturnValue().Set(WrapCapturedFrame(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ModeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AdvancedCapturedPhoto^>(info.This())) {
        return;
      }

      AdvancedCapturedPhoto *wrapper = AdvancedCapturedPhoto::Unwrap<AdvancedCapturedPhoto>(info.This());

      try  {
        ::Windows::Media::Devices::AdvancedPhotoMode result = wrapper->_instance->Mode;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void FrameBoundsRelativeToReferencePhotoGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AdvancedCapturedPhoto^>(info.This())) {
        return;
      }

      AdvancedCapturedPhoto *wrapper = AdvancedCapturedPhoto::Unwrap<AdvancedCapturedPhoto>(info.This());

      try  {
        ::Platform::IBox<::Windows::Foundation::Rect>^ result = wrapper->_instance->FrameBoundsRelativeToReferencePhoto;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(NodeRT::Utils::RectToJs(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::AdvancedCapturedPhoto^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAdvancedCapturedPhoto(::Windows::Media::Capture::AdvancedCapturedPhoto^ wintRtInstance);
      friend ::Windows::Media::Capture::AdvancedCapturedPhoto^ UnwrapAdvancedCapturedPhoto(Local<Value> value);
  };

  Persistent<FunctionTemplate> AdvancedCapturedPhoto::s_constructorTemplate;

  v8::Local<v8::Value> WrapAdvancedCapturedPhoto(::Windows::Media::Capture::AdvancedCapturedPhoto^ 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>(AdvancedCapturedPhoto::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AdvancedCapturedPhoto^ UnwrapAdvancedCapturedPhoto(Local<Value> value) {
     return AdvancedCapturedPhoto::Unwrap<AdvancedCapturedPhoto>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAdvancedCapturedPhoto(Local<Object> exports) {
    AdvancedCapturedPhoto::Init(exports);
  }

  class OptionalReferencePhotoCapturedEventArgs : 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>("OptionalReferencePhotoCapturedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("context").ToLocalChecked(), ContextGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("frame").ToLocalChecked(), FrameGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("OptionalReferencePhotoCapturedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      OptionalReferencePhotoCapturedEventArgs(::Windows::Media::Capture::OptionalReferencePhotoCapturedEventArgs^ 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::Media::Capture::OptionalReferencePhotoCapturedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::OptionalReferencePhotoCapturedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::OptionalReferencePhotoCapturedEventArgs^) 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());

      OptionalReferencePhotoCapturedEventArgs *wrapperInstance = new OptionalReferencePhotoCapturedEventArgs(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::Media::Capture::OptionalReferencePhotoCapturedEventArgs^>(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::Media::Capture::OptionalReferencePhotoCapturedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::OptionalReferencePhotoCapturedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapOptionalReferencePhotoCapturedEventArgs(winRtInstance));
    }





    static void ContextGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::OptionalReferencePhotoCapturedEventArgs^>(info.This())) {
        return;
      }

      OptionalReferencePhotoCapturedEventArgs *wrapper = OptionalReferencePhotoCapturedEventArgs::Unwrap<OptionalReferencePhotoCapturedEventArgs>(info.This());

      try  {
        ::Platform::Object^ result = wrapper->_instance->Context;
        info.GetReturnValue().Set(CreateOpaqueWrapper(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void FrameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::OptionalReferencePhotoCapturedEventArgs^>(info.This())) {
        return;
      }

      OptionalReferencePhotoCapturedEventArgs *wrapper = OptionalReferencePhotoCapturedEventArgs::Unwrap<OptionalReferencePhotoCapturedEventArgs>(info.This());

      try  {
        ::Windows::Media::Capture::CapturedFrame^ result = wrapper->_instance->Frame;
        info.GetReturnValue().Set(WrapCapturedFrame(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::OptionalReferencePhotoCapturedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapOptionalReferencePhotoCapturedEventArgs(::Windows::Media::Capture::OptionalReferencePhotoCapturedEventArgs^ wintRtInstance);
      friend ::Windows::Media::Capture::OptionalReferencePhotoCapturedEventArgs^ UnwrapOptionalReferencePhotoCapturedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> OptionalReferencePhotoCapturedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapOptionalReferencePhotoCapturedEventArgs(::Windows::Media::Capture::OptionalReferencePhotoCapturedEventArgs^ 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>(OptionalReferencePhotoCapturedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::OptionalReferencePhotoCapturedEventArgs^ UnwrapOptionalReferencePhotoCapturedEventArgs(Local<Value> value) {
     return OptionalReferencePhotoCapturedEventArgs::Unwrap<OptionalReferencePhotoCapturedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitOptionalReferencePhotoCapturedEventArgs(Local<Object> exports) {
    OptionalReferencePhotoCapturedEventArgs::Init(exports);
  }

  class CapturedFrame : 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>("CapturedFrame").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);

        Local<Function> func;
        Local<FunctionTemplate> funcTemplate;

          
            Nan::SetPrototypeMethod(localRef, "getInputStreamAt", GetInputStreamAt);
            Nan::SetPrototypeMethod(localRef, "getOutputStreamAt", GetOutputStreamAt);
            Nan::SetPrototypeMethod(localRef, "seek", Seek);
            Nan::SetPrototypeMethod(localRef, "cloneStream", CloneStream);
            Nan::SetPrototypeMethod(localRef, "close", Close);
          

          
            Nan::SetPrototypeMethod(localRef, "readAsync", ReadAsync);
            Nan::SetPrototypeMethod(localRef, "writeAsync", WriteAsync);
            Nan::SetPrototypeMethod(localRef, "flushAsync", FlushAsync);
          


          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("height").ToLocalChecked(), HeightGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("width").ToLocalChecked(), WidthGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("softwareBitmap").ToLocalChecked(), SoftwareBitmapGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("contentType").ToLocalChecked(), ContentTypeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("size").ToLocalChecked(), SizeGetter, SizeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("canRead").ToLocalChecked(), CanReadGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("canWrite").ToLocalChecked(), CanWriteGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("position").ToLocalChecked(), PositionGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("CapturedFrame").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      CapturedFrame(::Windows::Media::Capture::CapturedFrame^ 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::Media::Capture::CapturedFrame^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrame^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::CapturedFrame^) 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());

      CapturedFrame *wrapperInstance = new CapturedFrame(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::Media::Capture::CapturedFrame^>(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::Media::Capture::CapturedFrame^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::CapturedFrame^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapCapturedFrame(winRtInstance));
    }

    static void ReadAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrame^>(info.This())) {
        return;
      }

      if (info.Length() == 0 || !info[info.Length() -1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: No callback was given")));
        return;
      }

      CapturedFrame *wrapper = CapturedFrame::Unwrap<CapturedFrame>(info.This());

      ::Windows::Foundation::IAsyncOperationWithProgress<::Windows::Storage::Streams::IBuffer^, unsigned int>^ op;


      if (info.Length() == 4
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IBuffer^>(info[0])
        && info[1]->IsUint32()
        && info[2]->IsInt32())
      {
        try
        {
          ::Windows::Storage::Streams::IBuffer^ arg0 = dynamic_cast<::Windows::Storage::Streams::IBuffer^>(NodeRT::Utils::GetObjectInstance(info[0]));
          unsigned int arg1 = static_cast<unsigned int>(Nan::To<uint32_t>(info[1]).FromMaybe(0));
          ::Windows::Storage::Streams::InputStreamOptions arg2 = static_cast<::Windows::Storage::Streams::InputStreamOptions>(Nan::To<int32_t>(info[2]).FromMaybe(0));
          
          op = wrapper->_instance->ReadAsync(arg0,arg1,arg2);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

      auto opTask = create_task(op);
      uv_async_t* asyncToken = NodeUtils::Async::GetAsyncToken(info[info.Length() -1].As<Function>());

      opTask.then( [asyncToken] (task<::Windows::Storage::Streams::IBuffer^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = NodeRT::Utils::CreateExternalWinRTObject("Windows.Storage.Streams", "IBuffer", 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 WriteAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrame^>(info.This())) {
        return;
      }

      if (info.Length() == 0 || !info[info.Length() -1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: No callback was given")));
        return;
      }

      CapturedFrame *wrapper = CapturedFrame::Unwrap<CapturedFrame>(info.This());

      ::Windows::Foundation::IAsyncOperationWithProgress<unsigned int, unsigned int>^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IBuffer^>(info[0]))
      {
        try
        {
          ::Windows::Storage::Streams::IBuffer^ arg0 = dynamic_cast<::Windows::Storage::Streams::IBuffer^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          op = wrapper->_instance->WriteAsync(arg0);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

      auto opTask = create_task(op);
      uv_async_t* asyncToken = NodeUtils::Async::GetAsyncToken(info[info.Length() -1].As<Function>());

      opTask.then( [asyncToken] (task<unsigned int> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = Nan::New<Integer>(result);
              if (tryCatch.HasCaught())
              {
                error = Nan::To<Object>(tryCatch.Exception()).ToLocalChecked();
              }
              else
              {
                error = Undefined();
              }
              if (arg1.IsEmpty()) arg1 = Undefined();
            }
            Local<Value> args[] = {error, arg1};


            invokeCallback(_countof(args), args);
          });
        } catch (Platform::Exception^ exception) {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {
            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

            Local<Value> args[] = {error};
            invokeCallback(_countof(args), args);
          });
        }
      });
    }
    static void FlushAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrame^>(info.This())) {
        return;
      }

      if (info.Length() == 0 || !info[info.Length() -1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: No callback was given")));
        return;
      }

      CapturedFrame *wrapper = CapturedFrame::Unwrap<CapturedFrame>(info.This());

      ::Windows::Foundation::IAsyncOperation<bool>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->FlushAsync();
        }
        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 GetInputStreamAt(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrame^>(info.This())) {
        return;
      }

      CapturedFrame *wrapper = CapturedFrame::Unwrap<CapturedFrame>(info.This());

      if (info.Length() == 1
        && info[0]->IsNumber())
      {
        try
        {
          unsigned __int64 arg0 = static_cast<unsigned __int64>(Nan::To<int64_t>(info[0]).FromMaybe(0));
          
          ::Windows::Storage::Streams::IInputStream^ result;
          result = wrapper->_instance->GetInputStreamAt(arg0);
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Storage.Streams", "IInputStream", 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 GetOutputStreamAt(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrame^>(info.This())) {
        return;
      }

      CapturedFrame *wrapper = CapturedFrame::Unwrap<CapturedFrame>(info.This());

      if (info.Length() == 1
        && info[0]->IsNumber())
      {
        try
        {
          unsigned __int64 arg0 = static_cast<unsigned __int64>(Nan::To<int64_t>(info[0]).FromMaybe(0));
          
          ::Windows::Storage::Streams::IOutputStream^ result;
          result = wrapper->_instance->GetOutputStreamAt(arg0);
          info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Storage.Streams", "IOutputStream", 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 Seek(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrame^>(info.This())) {
        return;
      }

      CapturedFrame *wrapper = CapturedFrame::Unwrap<CapturedFrame>(info.This());

      if (info.Length() == 1
        && info[0]->IsNumber())
      {
        try
        {
          unsigned __int64 arg0 = static_cast<unsigned __int64>(Nan::To<int64_t>(info[0]).FromMaybe(0));
          
          wrapper->_instance->Seek(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 CloneStream(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrame^>(info.This())) {
        return;
      }

      CapturedFrame *wrapper = CapturedFrame::Unwrap<CapturedFrame>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Storage::Streams::IRandomAccessStream^ result;
          result = wrapper->_instance->CloneStream();
          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 Close(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrame^>(info.This())) {
        return;
      }

      CapturedFrame *wrapper = CapturedFrame::Unwrap<CapturedFrame>(info.This());

      if (info.Length() == 0) {
        try {
          delete wrapper->_instance;
          wrapper->_instance = nullptr;
          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 HeightGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrame^>(info.This())) {
        return;
      }

      CapturedFrame *wrapper = CapturedFrame::Unwrap<CapturedFrame>(info.This());

      try  {
        unsigned int result = wrapper->_instance->Height;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void WidthGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrame^>(info.This())) {
        return;
      }

      CapturedFrame *wrapper = CapturedFrame::Unwrap<CapturedFrame>(info.This());

      try  {
        unsigned int result = wrapper->_instance->Width;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SoftwareBitmapGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrame^>(info.This())) {
        return;
      }

      CapturedFrame *wrapper = CapturedFrame::Unwrap<CapturedFrame>(info.This());

      try  {
        ::Windows::Graphics::Imaging::SoftwareBitmap^ result = wrapper->_instance->SoftwareBitmap;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Graphics.Imaging", "SoftwareBitmap", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ContentTypeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrame^>(info.This())) {
        return;
      }

      CapturedFrame *wrapper = CapturedFrame::Unwrap<CapturedFrame>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->ContentType;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SizeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrame^>(info.This())) {
        return;
      }

      CapturedFrame *wrapper = CapturedFrame::Unwrap<CapturedFrame>(info.This());

      try  {
        unsigned __int64 result = wrapper->_instance->Size;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SizeSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrame^>(info.This())) {
        return;
      }

      CapturedFrame *wrapper = CapturedFrame::Unwrap<CapturedFrame>(info.This());

      try {

        unsigned __int64 winRtValue = static_cast<unsigned __int64>(Nan::To<int64_t>(value).FromMaybe(0));

        wrapper->_instance->Size = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void CanReadGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrame^>(info.This())) {
        return;
      }

      CapturedFrame *wrapper = CapturedFrame::Unwrap<CapturedFrame>(info.This());

      try  {
        bool result = wrapper->_instance->CanRead;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CanWriteGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrame^>(info.This())) {
        return;
      }

      CapturedFrame *wrapper = CapturedFrame::Unwrap<CapturedFrame>(info.This());

      try  {
        bool result = wrapper->_instance->CanWrite;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PositionGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrame^>(info.This())) {
        return;
      }

      CapturedFrame *wrapper = CapturedFrame::Unwrap<CapturedFrame>(info.This());

      try  {
        unsigned __int64 result = wrapper->_instance->Position;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::CapturedFrame^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapCapturedFrame(::Windows::Media::Capture::CapturedFrame^ wintRtInstance);
      friend ::Windows::Media::Capture::CapturedFrame^ UnwrapCapturedFrame(Local<Value> value);
  };

  Persistent<FunctionTemplate> CapturedFrame::s_constructorTemplate;

  v8::Local<v8::Value> WrapCapturedFrame(::Windows::Media::Capture::CapturedFrame^ 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>(CapturedFrame::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::CapturedFrame^ UnwrapCapturedFrame(Local<Value> value) {
     return CapturedFrame::Unwrap<CapturedFrame>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitCapturedFrame(Local<Object> exports) {
    CapturedFrame::Init(exports);
  }

  class PhotoCapturedEventArgs : 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>("PhotoCapturedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("captureTimeOffset").ToLocalChecked(), CaptureTimeOffsetGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("frame").ToLocalChecked(), FrameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("thumbnail").ToLocalChecked(), ThumbnailGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("PhotoCapturedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      PhotoCapturedEventArgs(::Windows::Media::Capture::PhotoCapturedEventArgs^ 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::Media::Capture::PhotoCapturedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::PhotoCapturedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::PhotoCapturedEventArgs^) 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());

      PhotoCapturedEventArgs *wrapperInstance = new PhotoCapturedEventArgs(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::Media::Capture::PhotoCapturedEventArgs^>(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::Media::Capture::PhotoCapturedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::PhotoCapturedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapPhotoCapturedEventArgs(winRtInstance));
    }





    static void CaptureTimeOffsetGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::PhotoCapturedEventArgs^>(info.This())) {
        return;
      }

      PhotoCapturedEventArgs *wrapper = PhotoCapturedEventArgs::Unwrap<PhotoCapturedEventArgs>(info.This());

      try  {
        ::Windows::Foundation::TimeSpan result = wrapper->_instance->CaptureTimeOffset;
        info.GetReturnValue().Set(Nan::New<Number>(result.Duration/10000.0));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void FrameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::PhotoCapturedEventArgs^>(info.This())) {
        return;
      }

      PhotoCapturedEventArgs *wrapper = PhotoCapturedEventArgs::Unwrap<PhotoCapturedEventArgs>(info.This());

      try  {
        ::Windows::Media::Capture::CapturedFrame^ result = wrapper->_instance->Frame;
        info.GetReturnValue().Set(WrapCapturedFrame(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ThumbnailGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::PhotoCapturedEventArgs^>(info.This())) {
        return;
      }

      PhotoCapturedEventArgs *wrapper = PhotoCapturedEventArgs::Unwrap<PhotoCapturedEventArgs>(info.This());

      try  {
        ::Windows::Media::Capture::CapturedFrame^ result = wrapper->_instance->Thumbnail;
        info.GetReturnValue().Set(WrapCapturedFrame(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::PhotoCapturedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapPhotoCapturedEventArgs(::Windows::Media::Capture::PhotoCapturedEventArgs^ wintRtInstance);
      friend ::Windows::Media::Capture::PhotoCapturedEventArgs^ UnwrapPhotoCapturedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> PhotoCapturedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapPhotoCapturedEventArgs(::Windows::Media::Capture::PhotoCapturedEventArgs^ 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>(PhotoCapturedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::PhotoCapturedEventArgs^ UnwrapPhotoCapturedEventArgs(Local<Value> value) {
     return PhotoCapturedEventArgs::Unwrap<PhotoCapturedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitPhotoCapturedEventArgs(Local<Object> exports) {
    PhotoCapturedEventArgs::Init(exports);
  }

  class CapturedFrameControlValues : 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>("CapturedFrameControlValues").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("exposure").ToLocalChecked(), ExposureGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("exposureCompensation").ToLocalChecked(), ExposureCompensationGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("flashPowerPercent").ToLocalChecked(), FlashPowerPercentGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("flashed").ToLocalChecked(), FlashedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("focus").ToLocalChecked(), FocusGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isoSpeed").ToLocalChecked(), IsoSpeedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("sceneMode").ToLocalChecked(), SceneModeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("whiteBalance").ToLocalChecked(), WhiteBalanceGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("zoomFactor").ToLocalChecked(), ZoomFactorGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("focusState").ToLocalChecked(), FocusStateGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isoAnalogGain").ToLocalChecked(), IsoAnalogGainGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isoDigitalGain").ToLocalChecked(), IsoDigitalGainGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("sensorFrameRate").ToLocalChecked(), SensorFrameRateGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("whiteBalanceGain").ToLocalChecked(), WhiteBalanceGainGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("CapturedFrameControlValues").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      CapturedFrameControlValues(::Windows::Media::Capture::CapturedFrameControlValues^ 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::Media::Capture::CapturedFrameControlValues^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrameControlValues^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::CapturedFrameControlValues^) 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());

      CapturedFrameControlValues *wrapperInstance = new CapturedFrameControlValues(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::Media::Capture::CapturedFrameControlValues^>(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::Media::Capture::CapturedFrameControlValues^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::CapturedFrameControlValues^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapCapturedFrameControlValues(winRtInstance));
    }





    static void ExposureGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrameControlValues^>(info.This())) {
        return;
      }

      CapturedFrameControlValues *wrapper = CapturedFrameControlValues::Unwrap<CapturedFrameControlValues>(info.This());

      try  {
        ::Platform::IBox<::Windows::Foundation::TimeSpan>^ result = wrapper->_instance->Exposure;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Number>(result->Value.Duration/10000.0)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ExposureCompensationGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrameControlValues^>(info.This())) {
        return;
      }

      CapturedFrameControlValues *wrapper = CapturedFrameControlValues::Unwrap<CapturedFrameControlValues>(info.This());

      try  {
        ::Platform::IBox<float>^ result = wrapper->_instance->ExposureCompensation;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Number>(static_cast<double>(result->Value))) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void FlashPowerPercentGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrameControlValues^>(info.This())) {
        return;
      }

      CapturedFrameControlValues *wrapper = CapturedFrameControlValues::Unwrap<CapturedFrameControlValues>(info.This());

      try  {
        ::Platform::IBox<float>^ result = wrapper->_instance->FlashPowerPercent;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Number>(static_cast<double>(result->Value))) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void FlashedGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrameControlValues^>(info.This())) {
        return;
      }

      CapturedFrameControlValues *wrapper = CapturedFrameControlValues::Unwrap<CapturedFrameControlValues>(info.This());

      try  {
        ::Platform::IBox<bool>^ result = wrapper->_instance->Flashed;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Boolean>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void FocusGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrameControlValues^>(info.This())) {
        return;
      }

      CapturedFrameControlValues *wrapper = CapturedFrameControlValues::Unwrap<CapturedFrameControlValues>(info.This());

      try  {
        ::Platform::IBox<unsigned int>^ result = wrapper->_instance->Focus;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsoSpeedGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrameControlValues^>(info.This())) {
        return;
      }

      CapturedFrameControlValues *wrapper = CapturedFrameControlValues::Unwrap<CapturedFrameControlValues>(info.This());

      try  {
        ::Platform::IBox<unsigned int>^ result = wrapper->_instance->IsoSpeed;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SceneModeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrameControlValues^>(info.This())) {
        return;
      }

      CapturedFrameControlValues *wrapper = CapturedFrameControlValues::Unwrap<CapturedFrameControlValues>(info.This());

      try  {
        ::Platform::IBox<::Windows::Media::Devices::CaptureSceneMode>^ result = wrapper->_instance->SceneMode;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(static_cast<int>(result->Value))) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void WhiteBalanceGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrameControlValues^>(info.This())) {
        return;
      }

      CapturedFrameControlValues *wrapper = CapturedFrameControlValues::Unwrap<CapturedFrameControlValues>(info.This());

      try  {
        ::Platform::IBox<unsigned int>^ result = wrapper->_instance->WhiteBalance;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ZoomFactorGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrameControlValues^>(info.This())) {
        return;
      }

      CapturedFrameControlValues *wrapper = CapturedFrameControlValues::Unwrap<CapturedFrameControlValues>(info.This());

      try  {
        ::Platform::IBox<float>^ result = wrapper->_instance->ZoomFactor;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Number>(static_cast<double>(result->Value))) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void FocusStateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrameControlValues^>(info.This())) {
        return;
      }

      CapturedFrameControlValues *wrapper = CapturedFrameControlValues::Unwrap<CapturedFrameControlValues>(info.This());

      try  {
        ::Platform::IBox<::Windows::Media::Devices::MediaCaptureFocusState>^ result = wrapper->_instance->FocusState;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(static_cast<int>(result->Value))) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsoAnalogGainGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrameControlValues^>(info.This())) {
        return;
      }

      CapturedFrameControlValues *wrapper = CapturedFrameControlValues::Unwrap<CapturedFrameControlValues>(info.This());

      try  {
        ::Platform::IBox<double>^ result = wrapper->_instance->IsoAnalogGain;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Number>(static_cast<double>(result->Value))) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsoDigitalGainGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrameControlValues^>(info.This())) {
        return;
      }

      CapturedFrameControlValues *wrapper = CapturedFrameControlValues::Unwrap<CapturedFrameControlValues>(info.This());

      try  {
        ::Platform::IBox<double>^ result = wrapper->_instance->IsoDigitalGain;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Number>(static_cast<double>(result->Value))) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SensorFrameRateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrameControlValues^>(info.This())) {
        return;
      }

      CapturedFrameControlValues *wrapper = CapturedFrameControlValues::Unwrap<CapturedFrameControlValues>(info.This());

      try  {
        ::Windows::Media::MediaProperties::MediaRatio^ result = wrapper->_instance->SensorFrameRate;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Media.MediaProperties", "MediaRatio", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void WhiteBalanceGainGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CapturedFrameControlValues^>(info.This())) {
        return;
      }

      CapturedFrameControlValues *wrapper = CapturedFrameControlValues::Unwrap<CapturedFrameControlValues>(info.This());

      try  {
        ::Platform::IBox<::Windows::Media::Capture::WhiteBalanceGain>^ result = wrapper->_instance->WhiteBalanceGain;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(WhiteBalanceGainToJsObject(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::CapturedFrameControlValues^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapCapturedFrameControlValues(::Windows::Media::Capture::CapturedFrameControlValues^ wintRtInstance);
      friend ::Windows::Media::Capture::CapturedFrameControlValues^ UnwrapCapturedFrameControlValues(Local<Value> value);
  };

  Persistent<FunctionTemplate> CapturedFrameControlValues::s_constructorTemplate;

  v8::Local<v8::Value> WrapCapturedFrameControlValues(::Windows::Media::Capture::CapturedFrameControlValues^ 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>(CapturedFrameControlValues::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::CapturedFrameControlValues^ UnwrapCapturedFrameControlValues(Local<Value> value) {
     return CapturedFrameControlValues::Unwrap<CapturedFrameControlValues>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitCapturedFrameControlValues(Local<Object> exports) {
    CapturedFrameControlValues::Init(exports);
  }

  class VideoStreamConfiguration : 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>("VideoStreamConfiguration").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("inputProperties").ToLocalChecked(), InputPropertiesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("outputProperties").ToLocalChecked(), OutputPropertiesGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("VideoStreamConfiguration").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      VideoStreamConfiguration(::Windows::Media::Capture::VideoStreamConfiguration^ 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::Media::Capture::VideoStreamConfiguration^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::VideoStreamConfiguration^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::VideoStreamConfiguration^) 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());

      VideoStreamConfiguration *wrapperInstance = new VideoStreamConfiguration(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::Media::Capture::VideoStreamConfiguration^>(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::Media::Capture::VideoStreamConfiguration^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::VideoStreamConfiguration^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapVideoStreamConfiguration(winRtInstance));
    }





    static void InputPropertiesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::VideoStreamConfiguration^>(info.This())) {
        return;
      }

      VideoStreamConfiguration *wrapper = VideoStreamConfiguration::Unwrap<VideoStreamConfiguration>(info.This());

      try  {
        ::Windows::Media::MediaProperties::VideoEncodingProperties^ result = wrapper->_instance->InputProperties;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Media.MediaProperties", "VideoEncodingProperties", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void OutputPropertiesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::VideoStreamConfiguration^>(info.This())) {
        return;
      }

      VideoStreamConfiguration *wrapper = VideoStreamConfiguration::Unwrap<VideoStreamConfiguration>(info.This());

      try  {
        ::Windows::Media::MediaProperties::VideoEncodingProperties^ result = wrapper->_instance->OutputProperties;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Media.MediaProperties", "VideoEncodingProperties", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::VideoStreamConfiguration^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapVideoStreamConfiguration(::Windows::Media::Capture::VideoStreamConfiguration^ wintRtInstance);
      friend ::Windows::Media::Capture::VideoStreamConfiguration^ UnwrapVideoStreamConfiguration(Local<Value> value);
  };

  Persistent<FunctionTemplate> VideoStreamConfiguration::s_constructorTemplate;

  v8::Local<v8::Value> WrapVideoStreamConfiguration(::Windows::Media::Capture::VideoStreamConfiguration^ 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>(VideoStreamConfiguration::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::VideoStreamConfiguration^ UnwrapVideoStreamConfiguration(Local<Value> value) {
     return VideoStreamConfiguration::Unwrap<VideoStreamConfiguration>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitVideoStreamConfiguration(Local<Object> exports) {
    VideoStreamConfiguration::Init(exports);
  }

  class AppBroadcastGlobalSettings : 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>("AppBroadcastGlobalSettings").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("systemAudioGain").ToLocalChecked(), SystemAudioGainGetter, SystemAudioGainSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("selectedCameraId").ToLocalChecked(), SelectedCameraIdGetter, SelectedCameraIdSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("microphoneGain").ToLocalChecked(), MicrophoneGainGetter, MicrophoneGainSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isMicrophoneCaptureEnabledByDefault").ToLocalChecked(), IsMicrophoneCaptureEnabledByDefaultGetter, IsMicrophoneCaptureEnabledByDefaultSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isEchoCancellationEnabled").ToLocalChecked(), IsEchoCancellationEnabledGetter, IsEchoCancellationEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isCursorImageCaptureEnabled").ToLocalChecked(), IsCursorImageCaptureEnabledGetter, IsCursorImageCaptureEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isCameraCaptureEnabledByDefault").ToLocalChecked(), IsCameraCaptureEnabledByDefaultGetter, IsCameraCaptureEnabledByDefaultSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isAudioCaptureEnabled").ToLocalChecked(), IsAudioCaptureEnabledGetter, IsAudioCaptureEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("cameraOverlaySize").ToLocalChecked(), CameraOverlaySizeGetter, CameraOverlaySizeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("cameraOverlayLocation").ToLocalChecked(), CameraOverlayLocationGetter, CameraOverlayLocationSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("hasHardwareEncoder").ToLocalChecked(), HasHardwareEncoderGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isBroadcastEnabled").ToLocalChecked(), IsBroadcastEnabledGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isDisabledByPolicy").ToLocalChecked(), IsDisabledByPolicyGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isGpuConstrained").ToLocalChecked(), IsGpuConstrainedGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppBroadcastGlobalSettings").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppBroadcastGlobalSettings(::Windows::Media::Capture::AppBroadcastGlobalSettings^ 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::Media::Capture::AppBroadcastGlobalSettings^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastGlobalSettings^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppBroadcastGlobalSettings^) 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());

      AppBroadcastGlobalSettings *wrapperInstance = new AppBroadcastGlobalSettings(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::Media::Capture::AppBroadcastGlobalSettings^>(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::Media::Capture::AppBroadcastGlobalSettings^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppBroadcastGlobalSettings^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppBroadcastGlobalSettings(winRtInstance));
    }





    static void SystemAudioGainGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastGlobalSettings^>(info.This())) {
        return;
      }

      AppBroadcastGlobalSettings *wrapper = AppBroadcastGlobalSettings::Unwrap<AppBroadcastGlobalSettings>(info.This());

      try  {
        double result = wrapper->_instance->SystemAudioGain;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SystemAudioGainSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastGlobalSettings^>(info.This())) {
        return;
      }

      AppBroadcastGlobalSettings *wrapper = AppBroadcastGlobalSettings::Unwrap<AppBroadcastGlobalSettings>(info.This());

      try {

        double winRtValue = Nan::To<double>(value).FromMaybe(0.0);

        wrapper->_instance->SystemAudioGain = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void SelectedCameraIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastGlobalSettings^>(info.This())) {
        return;
      }

      AppBroadcastGlobalSettings *wrapper = AppBroadcastGlobalSettings::Unwrap<AppBroadcastGlobalSettings>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->SelectedCameraId;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SelectedCameraIdSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsString()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastGlobalSettings^>(info.This())) {
        return;
      }

      AppBroadcastGlobalSettings *wrapper = AppBroadcastGlobalSettings::Unwrap<AppBroadcastGlobalSettings>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->SelectedCameraId = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void MicrophoneGainGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastGlobalSettings^>(info.This())) {
        return;
      }

      AppBroadcastGlobalSettings *wrapper = AppBroadcastGlobalSettings::Unwrap<AppBroadcastGlobalSettings>(info.This());

      try  {
        double result = wrapper->_instance->MicrophoneGain;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MicrophoneGainSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastGlobalSettings^>(info.This())) {
        return;
      }

      AppBroadcastGlobalSettings *wrapper = AppBroadcastGlobalSettings::Unwrap<AppBroadcastGlobalSettings>(info.This());

      try {

        double winRtValue = Nan::To<double>(value).FromMaybe(0.0);

        wrapper->_instance->MicrophoneGain = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsMicrophoneCaptureEnabledByDefaultGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastGlobalSettings^>(info.This())) {
        return;
      }

      AppBroadcastGlobalSettings *wrapper = AppBroadcastGlobalSettings::Unwrap<AppBroadcastGlobalSettings>(info.This());

      try  {
        bool result = wrapper->_instance->IsMicrophoneCaptureEnabledByDefault;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsMicrophoneCaptureEnabledByDefaultSetter(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::Media::Capture::AppBroadcastGlobalSettings^>(info.This())) {
        return;
      }

      AppBroadcastGlobalSettings *wrapper = AppBroadcastGlobalSettings::Unwrap<AppBroadcastGlobalSettings>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsMicrophoneCaptureEnabledByDefault = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsEchoCancellationEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastGlobalSettings^>(info.This())) {
        return;
      }

      AppBroadcastGlobalSettings *wrapper = AppBroadcastGlobalSettings::Unwrap<AppBroadcastGlobalSettings>(info.This());

      try  {
        bool result = wrapper->_instance->IsEchoCancellationEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsEchoCancellationEnabledSetter(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::Media::Capture::AppBroadcastGlobalSettings^>(info.This())) {
        return;
      }

      AppBroadcastGlobalSettings *wrapper = AppBroadcastGlobalSettings::Unwrap<AppBroadcastGlobalSettings>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsEchoCancellationEnabled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsCursorImageCaptureEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastGlobalSettings^>(info.This())) {
        return;
      }

      AppBroadcastGlobalSettings *wrapper = AppBroadcastGlobalSettings::Unwrap<AppBroadcastGlobalSettings>(info.This());

      try  {
        bool result = wrapper->_instance->IsCursorImageCaptureEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsCursorImageCaptureEnabledSetter(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::Media::Capture::AppBroadcastGlobalSettings^>(info.This())) {
        return;
      }

      AppBroadcastGlobalSettings *wrapper = AppBroadcastGlobalSettings::Unwrap<AppBroadcastGlobalSettings>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsCursorImageCaptureEnabled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsCameraCaptureEnabledByDefaultGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastGlobalSettings^>(info.This())) {
        return;
      }

      AppBroadcastGlobalSettings *wrapper = AppBroadcastGlobalSettings::Unwrap<AppBroadcastGlobalSettings>(info.This());

      try  {
        bool result = wrapper->_instance->IsCameraCaptureEnabledByDefault;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsCameraCaptureEnabledByDefaultSetter(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::Media::Capture::AppBroadcastGlobalSettings^>(info.This())) {
        return;
      }

      AppBroadcastGlobalSettings *wrapper = AppBroadcastGlobalSettings::Unwrap<AppBroadcastGlobalSettings>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsCameraCaptureEnabledByDefault = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsAudioCaptureEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastGlobalSettings^>(info.This())) {
        return;
      }

      AppBroadcastGlobalSettings *wrapper = AppBroadcastGlobalSettings::Unwrap<AppBroadcastGlobalSettings>(info.This());

      try  {
        bool result = wrapper->_instance->IsAudioCaptureEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsAudioCaptureEnabledSetter(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::Media::Capture::AppBroadcastGlobalSettings^>(info.This())) {
        return;
      }

      AppBroadcastGlobalSettings *wrapper = AppBroadcastGlobalSettings::Unwrap<AppBroadcastGlobalSettings>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsAudioCaptureEnabled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void CameraOverlaySizeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastGlobalSettings^>(info.This())) {
        return;
      }

      AppBroadcastGlobalSettings *wrapper = AppBroadcastGlobalSettings::Unwrap<AppBroadcastGlobalSettings>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastCameraOverlaySize result = wrapper->_instance->CameraOverlaySize;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CameraOverlaySizeSetter(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::Media::Capture::AppBroadcastGlobalSettings^>(info.This())) {
        return;
      }

      AppBroadcastGlobalSettings *wrapper = AppBroadcastGlobalSettings::Unwrap<AppBroadcastGlobalSettings>(info.This());

      try {

        ::Windows::Media::Capture::AppBroadcastCameraOverlaySize winRtValue = static_cast<::Windows::Media::Capture::AppBroadcastCameraOverlaySize>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->CameraOverlaySize = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void CameraOverlayLocationGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastGlobalSettings^>(info.This())) {
        return;
      }

      AppBroadcastGlobalSettings *wrapper = AppBroadcastGlobalSettings::Unwrap<AppBroadcastGlobalSettings>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastCameraOverlayLocation result = wrapper->_instance->CameraOverlayLocation;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CameraOverlayLocationSetter(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::Media::Capture::AppBroadcastGlobalSettings^>(info.This())) {
        return;
      }

      AppBroadcastGlobalSettings *wrapper = AppBroadcastGlobalSettings::Unwrap<AppBroadcastGlobalSettings>(info.This());

      try {

        ::Windows::Media::Capture::AppBroadcastCameraOverlayLocation winRtValue = static_cast<::Windows::Media::Capture::AppBroadcastCameraOverlayLocation>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->CameraOverlayLocation = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void HasHardwareEncoderGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastGlobalSettings^>(info.This())) {
        return;
      }

      AppBroadcastGlobalSettings *wrapper = AppBroadcastGlobalSettings::Unwrap<AppBroadcastGlobalSettings>(info.This());

      try  {
        bool result = wrapper->_instance->HasHardwareEncoder;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsBroadcastEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastGlobalSettings^>(info.This())) {
        return;
      }

      AppBroadcastGlobalSettings *wrapper = AppBroadcastGlobalSettings::Unwrap<AppBroadcastGlobalSettings>(info.This());

      try  {
        bool result = wrapper->_instance->IsBroadcastEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsDisabledByPolicyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastGlobalSettings^>(info.This())) {
        return;
      }

      AppBroadcastGlobalSettings *wrapper = AppBroadcastGlobalSettings::Unwrap<AppBroadcastGlobalSettings>(info.This());

      try  {
        bool result = wrapper->_instance->IsDisabledByPolicy;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsGpuConstrainedGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastGlobalSettings^>(info.This())) {
        return;
      }

      AppBroadcastGlobalSettings *wrapper = AppBroadcastGlobalSettings::Unwrap<AppBroadcastGlobalSettings>(info.This());

      try  {
        bool result = wrapper->_instance->IsGpuConstrained;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::AppBroadcastGlobalSettings^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppBroadcastGlobalSettings(::Windows::Media::Capture::AppBroadcastGlobalSettings^ wintRtInstance);
      friend ::Windows::Media::Capture::AppBroadcastGlobalSettings^ UnwrapAppBroadcastGlobalSettings(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppBroadcastGlobalSettings::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppBroadcastGlobalSettings(::Windows::Media::Capture::AppBroadcastGlobalSettings^ 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>(AppBroadcastGlobalSettings::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppBroadcastGlobalSettings^ UnwrapAppBroadcastGlobalSettings(Local<Value> value) {
     return AppBroadcastGlobalSettings::Unwrap<AppBroadcastGlobalSettings>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppBroadcastGlobalSettings(Local<Object> exports) {
    AppBroadcastGlobalSettings::Init(exports);
  }

  class AppBroadcastProviderSettings : 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>("AppBroadcastProviderSettings").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoEncodingResolutionMode").ToLocalChecked(), VideoEncodingResolutionModeGetter, VideoEncodingResolutionModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoEncodingBitrateMode").ToLocalChecked(), VideoEncodingBitrateModeGetter, VideoEncodingBitrateModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("defaultBroadcastTitle").ToLocalChecked(), DefaultBroadcastTitleGetter, DefaultBroadcastTitleSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("customVideoEncodingWidth").ToLocalChecked(), CustomVideoEncodingWidthGetter, CustomVideoEncodingWidthSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("customVideoEncodingHeight").ToLocalChecked(), CustomVideoEncodingHeightGetter, CustomVideoEncodingHeightSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("customVideoEncodingBitrate").ToLocalChecked(), CustomVideoEncodingBitrateGetter, CustomVideoEncodingBitrateSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("audioEncodingBitrate").ToLocalChecked(), AudioEncodingBitrateGetter, AudioEncodingBitrateSetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppBroadcastProviderSettings").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppBroadcastProviderSettings(::Windows::Media::Capture::AppBroadcastProviderSettings^ 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::Media::Capture::AppBroadcastProviderSettings^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastProviderSettings^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppBroadcastProviderSettings^) 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());

      AppBroadcastProviderSettings *wrapperInstance = new AppBroadcastProviderSettings(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::Media::Capture::AppBroadcastProviderSettings^>(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::Media::Capture::AppBroadcastProviderSettings^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppBroadcastProviderSettings^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppBroadcastProviderSettings(winRtInstance));
    }





    static void VideoEncodingResolutionModeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastProviderSettings^>(info.This())) {
        return;
      }

      AppBroadcastProviderSettings *wrapper = AppBroadcastProviderSettings::Unwrap<AppBroadcastProviderSettings>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastVideoEncodingResolutionMode result = wrapper->_instance->VideoEncodingResolutionMode;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VideoEncodingResolutionModeSetter(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::Media::Capture::AppBroadcastProviderSettings^>(info.This())) {
        return;
      }

      AppBroadcastProviderSettings *wrapper = AppBroadcastProviderSettings::Unwrap<AppBroadcastProviderSettings>(info.This());

      try {

        ::Windows::Media::Capture::AppBroadcastVideoEncodingResolutionMode winRtValue = static_cast<::Windows::Media::Capture::AppBroadcastVideoEncodingResolutionMode>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->VideoEncodingResolutionMode = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void VideoEncodingBitrateModeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastProviderSettings^>(info.This())) {
        return;
      }

      AppBroadcastProviderSettings *wrapper = AppBroadcastProviderSettings::Unwrap<AppBroadcastProviderSettings>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastVideoEncodingBitrateMode result = wrapper->_instance->VideoEncodingBitrateMode;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VideoEncodingBitrateModeSetter(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::Media::Capture::AppBroadcastProviderSettings^>(info.This())) {
        return;
      }

      AppBroadcastProviderSettings *wrapper = AppBroadcastProviderSettings::Unwrap<AppBroadcastProviderSettings>(info.This());

      try {

        ::Windows::Media::Capture::AppBroadcastVideoEncodingBitrateMode winRtValue = static_cast<::Windows::Media::Capture::AppBroadcastVideoEncodingBitrateMode>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->VideoEncodingBitrateMode = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void DefaultBroadcastTitleGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastProviderSettings^>(info.This())) {
        return;
      }

      AppBroadcastProviderSettings *wrapper = AppBroadcastProviderSettings::Unwrap<AppBroadcastProviderSettings>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->DefaultBroadcastTitle;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DefaultBroadcastTitleSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsString()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastProviderSettings^>(info.This())) {
        return;
      }

      AppBroadcastProviderSettings *wrapper = AppBroadcastProviderSettings::Unwrap<AppBroadcastProviderSettings>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->DefaultBroadcastTitle = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void CustomVideoEncodingWidthGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastProviderSettings^>(info.This())) {
        return;
      }

      AppBroadcastProviderSettings *wrapper = AppBroadcastProviderSettings::Unwrap<AppBroadcastProviderSettings>(info.This());

      try  {
        unsigned int result = wrapper->_instance->CustomVideoEncodingWidth;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CustomVideoEncodingWidthSetter(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::Media::Capture::AppBroadcastProviderSettings^>(info.This())) {
        return;
      }

      AppBroadcastProviderSettings *wrapper = AppBroadcastProviderSettings::Unwrap<AppBroadcastProviderSettings>(info.This());

      try {

        unsigned int winRtValue = static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));

        wrapper->_instance->CustomVideoEncodingWidth = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void CustomVideoEncodingHeightGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastProviderSettings^>(info.This())) {
        return;
      }

      AppBroadcastProviderSettings *wrapper = AppBroadcastProviderSettings::Unwrap<AppBroadcastProviderSettings>(info.This());

      try  {
        unsigned int result = wrapper->_instance->CustomVideoEncodingHeight;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CustomVideoEncodingHeightSetter(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::Media::Capture::AppBroadcastProviderSettings^>(info.This())) {
        return;
      }

      AppBroadcastProviderSettings *wrapper = AppBroadcastProviderSettings::Unwrap<AppBroadcastProviderSettings>(info.This());

      try {

        unsigned int winRtValue = static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));

        wrapper->_instance->CustomVideoEncodingHeight = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void CustomVideoEncodingBitrateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastProviderSettings^>(info.This())) {
        return;
      }

      AppBroadcastProviderSettings *wrapper = AppBroadcastProviderSettings::Unwrap<AppBroadcastProviderSettings>(info.This());

      try  {
        unsigned int result = wrapper->_instance->CustomVideoEncodingBitrate;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CustomVideoEncodingBitrateSetter(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::Media::Capture::AppBroadcastProviderSettings^>(info.This())) {
        return;
      }

      AppBroadcastProviderSettings *wrapper = AppBroadcastProviderSettings::Unwrap<AppBroadcastProviderSettings>(info.This());

      try {

        unsigned int winRtValue = static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));

        wrapper->_instance->CustomVideoEncodingBitrate = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void AudioEncodingBitrateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastProviderSettings^>(info.This())) {
        return;
      }

      AppBroadcastProviderSettings *wrapper = AppBroadcastProviderSettings::Unwrap<AppBroadcastProviderSettings>(info.This());

      try  {
        unsigned int result = wrapper->_instance->AudioEncodingBitrate;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AudioEncodingBitrateSetter(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::Media::Capture::AppBroadcastProviderSettings^>(info.This())) {
        return;
      }

      AppBroadcastProviderSettings *wrapper = AppBroadcastProviderSettings::Unwrap<AppBroadcastProviderSettings>(info.This());

      try {

        unsigned int winRtValue = static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));

        wrapper->_instance->AudioEncodingBitrate = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      


    private:
      ::Windows::Media::Capture::AppBroadcastProviderSettings^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppBroadcastProviderSettings(::Windows::Media::Capture::AppBroadcastProviderSettings^ wintRtInstance);
      friend ::Windows::Media::Capture::AppBroadcastProviderSettings^ UnwrapAppBroadcastProviderSettings(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppBroadcastProviderSettings::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppBroadcastProviderSettings(::Windows::Media::Capture::AppBroadcastProviderSettings^ 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>(AppBroadcastProviderSettings::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppBroadcastProviderSettings^ UnwrapAppBroadcastProviderSettings(Local<Value> value) {
     return AppBroadcastProviderSettings::Unwrap<AppBroadcastProviderSettings>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppBroadcastProviderSettings(Local<Object> exports) {
    AppBroadcastProviderSettings::Init(exports);
  }

  class AppBroadcastManager : 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>("AppBroadcastManager").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);






        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetMethod(constructor, "getGlobalSettings", GetGlobalSettings);
        Nan::SetMethod(constructor, "applyGlobalSettings", ApplyGlobalSettings);
        Nan::SetMethod(constructor, "getProviderSettings", GetProviderSettings);
        Nan::SetMethod(constructor, "applyProviderSettings", ApplyProviderSettings);


        Nan::Set(exports, Nan::New<String>("AppBroadcastManager").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppBroadcastManager(::Windows::Media::Capture::AppBroadcastManager^ 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::Media::Capture::AppBroadcastManager^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastManager^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppBroadcastManager^) 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());

      AppBroadcastManager *wrapperInstance = new AppBroadcastManager(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::Media::Capture::AppBroadcastManager^>(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::Media::Capture::AppBroadcastManager^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppBroadcastManager^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppBroadcastManager(winRtInstance));
    }





    static void GetGlobalSettings(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Media::Capture::AppBroadcastGlobalSettings^ result;
          result = ::Windows::Media::Capture::AppBroadcastManager::GetGlobalSettings();
          info.GetReturnValue().Set(WrapAppBroadcastGlobalSettings(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 ApplyGlobalSettings(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastGlobalSettings^>(info[0]))
      {
        try
        {
          ::Windows::Media::Capture::AppBroadcastGlobalSettings^ arg0 = UnwrapAppBroadcastGlobalSettings(info[0]);
          
          ::Windows::Media::Capture::AppBroadcastManager::ApplyGlobalSettings(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 GetProviderSettings(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Media::Capture::AppBroadcastProviderSettings^ result;
          result = ::Windows::Media::Capture::AppBroadcastManager::GetProviderSettings();
          info.GetReturnValue().Set(WrapAppBroadcastProviderSettings(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 ApplyProviderSettings(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastProviderSettings^>(info[0]))
      {
        try
        {
          ::Windows::Media::Capture::AppBroadcastProviderSettings^ arg0 = UnwrapAppBroadcastProviderSettings(info[0]);
          
          ::Windows::Media::Capture::AppBroadcastManager::ApplyProviderSettings(arg0);
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    private:
      ::Windows::Media::Capture::AppBroadcastManager^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppBroadcastManager(::Windows::Media::Capture::AppBroadcastManager^ wintRtInstance);
      friend ::Windows::Media::Capture::AppBroadcastManager^ UnwrapAppBroadcastManager(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppBroadcastManager::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppBroadcastManager(::Windows::Media::Capture::AppBroadcastManager^ 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>(AppBroadcastManager::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppBroadcastManager^ UnwrapAppBroadcastManager(Local<Value> value) {
     return AppBroadcastManager::Unwrap<AppBroadcastManager>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppBroadcastManager(Local<Object> exports) {
    AppBroadcastManager::Init(exports);
  }

  class AppBroadcastBackgroundServiceSignInInfo : 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>("AppBroadcastBackgroundServiceSignInInfo").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>("userName").ToLocalChecked(), UserNameGetter, UserNameSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("oAuthRequestUri").ToLocalChecked(), OAuthRequestUriGetter, OAuthRequestUriSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("oAuthCallbackUri").ToLocalChecked(), OAuthCallbackUriGetter, OAuthCallbackUriSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("authenticationResult").ToLocalChecked(), AuthenticationResultGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("signInState").ToLocalChecked(), SignInStateGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppBroadcastBackgroundServiceSignInInfo").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppBroadcastBackgroundServiceSignInInfo(::Windows::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^ 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::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^) 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());

      AppBroadcastBackgroundServiceSignInInfo *wrapperInstance = new AppBroadcastBackgroundServiceSignInInfo(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::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^>(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::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppBroadcastBackgroundServiceSignInInfo(winRtInstance));
    }





    static void UserNameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^>(info.This())) {
        return;
      }

      AppBroadcastBackgroundServiceSignInInfo *wrapper = AppBroadcastBackgroundServiceSignInInfo::Unwrap<AppBroadcastBackgroundServiceSignInInfo>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->UserName;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void UserNameSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsString()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^>(info.This())) {
        return;
      }

      AppBroadcastBackgroundServiceSignInInfo *wrapper = AppBroadcastBackgroundServiceSignInInfo::Unwrap<AppBroadcastBackgroundServiceSignInInfo>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->UserName = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void OAuthRequestUriGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^>(info.This())) {
        return;
      }

      AppBroadcastBackgroundServiceSignInInfo *wrapper = AppBroadcastBackgroundServiceSignInInfo::Unwrap<AppBroadcastBackgroundServiceSignInInfo>(info.This());

      try  {
        ::Windows::Foundation::Uri^ result = wrapper->_instance->OAuthRequestUri;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "Uri", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void OAuthRequestUriSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^>(info.This())) {
        return;
      }

      AppBroadcastBackgroundServiceSignInInfo *wrapper = AppBroadcastBackgroundServiceSignInInfo::Unwrap<AppBroadcastBackgroundServiceSignInInfo>(info.This());

      try {

        ::Windows::Foundation::Uri^ winRtValue = dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->OAuthRequestUri = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void OAuthCallbackUriGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^>(info.This())) {
        return;
      }

      AppBroadcastBackgroundServiceSignInInfo *wrapper = AppBroadcastBackgroundServiceSignInInfo::Unwrap<AppBroadcastBackgroundServiceSignInInfo>(info.This());

      try  {
        ::Windows::Foundation::Uri^ result = wrapper->_instance->OAuthCallbackUri;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "Uri", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void OAuthCallbackUriSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Uri^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^>(info.This())) {
        return;
      }

      AppBroadcastBackgroundServiceSignInInfo *wrapper = AppBroadcastBackgroundServiceSignInInfo::Unwrap<AppBroadcastBackgroundServiceSignInInfo>(info.This());

      try {

        ::Windows::Foundation::Uri^ winRtValue = dynamic_cast<::Windows::Foundation::Uri^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->OAuthCallbackUri = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void AuthenticationResultGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^>(info.This())) {
        return;
      }

      AppBroadcastBackgroundServiceSignInInfo *wrapper = AppBroadcastBackgroundServiceSignInInfo::Unwrap<AppBroadcastBackgroundServiceSignInInfo>(info.This());

      try  {
        ::Windows::Security::Authentication::Web::WebAuthenticationResult^ result = wrapper->_instance->AuthenticationResult;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Security.Authentication.Web", "WebAuthenticationResult", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SignInStateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^>(info.This())) {
        return;
      }

      AppBroadcastBackgroundServiceSignInInfo *wrapper = AppBroadcastBackgroundServiceSignInInfo::Unwrap<AppBroadcastBackgroundServiceSignInInfo>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastSignInState result = wrapper->_instance->SignInState;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    static void AddListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"signInStateChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^>(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;
        }
        AppBroadcastBackgroundServiceSignInInfo *wrapper = AppBroadcastBackgroundServiceSignInInfo::Unwrap<AppBroadcastBackgroundServiceSignInInfo>(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->SignInStateChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^, ::Windows::Media::Capture::AppBroadcastSignInStateChangedEventArgs^>(
            [callbackObjPtr](::Windows::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^ arg0, ::Windows::Media::Capture::AppBroadcastSignInStateChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAppBroadcastBackgroundServiceSignInInfo(arg0);
                  wrappedArg1 = WrapAppBroadcastSignInStateChangedEventArgs(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"signInStateChanged", 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"signInStateChanged", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^>(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;
          }
          AppBroadcastBackgroundServiceSignInInfo *wrapper = AppBroadcastBackgroundServiceSignInInfo::Unwrap<AppBroadcastBackgroundServiceSignInInfo>(info.This());
          wrapper->_instance->SignInStateChanged::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::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppBroadcastBackgroundServiceSignInInfo(::Windows::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^ wintRtInstance);
      friend ::Windows::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^ UnwrapAppBroadcastBackgroundServiceSignInInfo(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppBroadcastBackgroundServiceSignInInfo::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppBroadcastBackgroundServiceSignInInfo(::Windows::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^ 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>(AppBroadcastBackgroundServiceSignInInfo::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^ UnwrapAppBroadcastBackgroundServiceSignInInfo(Local<Value> value) {
     return AppBroadcastBackgroundServiceSignInInfo::Unwrap<AppBroadcastBackgroundServiceSignInInfo>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppBroadcastBackgroundServiceSignInInfo(Local<Object> exports) {
    AppBroadcastBackgroundServiceSignInInfo::Init(exports);
  }

  class AppBroadcastSignInStateChangedEventArgs : 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>("AppBroadcastSignInStateChangedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("result").ToLocalChecked(), ResultGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("signInState").ToLocalChecked(), SignInStateGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppBroadcastSignInStateChangedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppBroadcastSignInStateChangedEventArgs(::Windows::Media::Capture::AppBroadcastSignInStateChangedEventArgs^ 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::Media::Capture::AppBroadcastSignInStateChangedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastSignInStateChangedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppBroadcastSignInStateChangedEventArgs^) 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());

      AppBroadcastSignInStateChangedEventArgs *wrapperInstance = new AppBroadcastSignInStateChangedEventArgs(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::Media::Capture::AppBroadcastSignInStateChangedEventArgs^>(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::Media::Capture::AppBroadcastSignInStateChangedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppBroadcastSignInStateChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppBroadcastSignInStateChangedEventArgs(winRtInstance));
    }





    static void ResultGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastSignInStateChangedEventArgs^>(info.This())) {
        return;
      }

      AppBroadcastSignInStateChangedEventArgs *wrapper = AppBroadcastSignInStateChangedEventArgs::Unwrap<AppBroadcastSignInStateChangedEventArgs>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastSignInResult result = wrapper->_instance->Result;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SignInStateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastSignInStateChangedEventArgs^>(info.This())) {
        return;
      }

      AppBroadcastSignInStateChangedEventArgs *wrapper = AppBroadcastSignInStateChangedEventArgs::Unwrap<AppBroadcastSignInStateChangedEventArgs>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastSignInState result = wrapper->_instance->SignInState;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::AppBroadcastSignInStateChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppBroadcastSignInStateChangedEventArgs(::Windows::Media::Capture::AppBroadcastSignInStateChangedEventArgs^ wintRtInstance);
      friend ::Windows::Media::Capture::AppBroadcastSignInStateChangedEventArgs^ UnwrapAppBroadcastSignInStateChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppBroadcastSignInStateChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppBroadcastSignInStateChangedEventArgs(::Windows::Media::Capture::AppBroadcastSignInStateChangedEventArgs^ 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>(AppBroadcastSignInStateChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppBroadcastSignInStateChangedEventArgs^ UnwrapAppBroadcastSignInStateChangedEventArgs(Local<Value> value) {
     return AppBroadcastSignInStateChangedEventArgs::Unwrap<AppBroadcastSignInStateChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppBroadcastSignInStateChangedEventArgs(Local<Object> exports) {
    AppBroadcastSignInStateChangedEventArgs::Init(exports);
  }

  class AppBroadcastStreamReader : 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>("AppBroadcastStreamReader").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "tryGetNextAudioFrame", TryGetNextAudioFrame);
            Nan::SetPrototypeMethod(localRef, "tryGetNextVideoFrame", TryGetNextVideoFrame);
          


          
          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>("audioAacSequence").ToLocalChecked(), AudioAacSequenceGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("audioBitrate").ToLocalChecked(), AudioBitrateGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("audioChannels").ToLocalChecked(), AudioChannelsGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("audioSampleRate").ToLocalChecked(), AudioSampleRateGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoBitrate").ToLocalChecked(), VideoBitrateGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoHeight").ToLocalChecked(), VideoHeightGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoWidth").ToLocalChecked(), VideoWidthGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppBroadcastStreamReader").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppBroadcastStreamReader(::Windows::Media::Capture::AppBroadcastStreamReader^ 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::Media::Capture::AppBroadcastStreamReader^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamReader^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppBroadcastStreamReader^) 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());

      AppBroadcastStreamReader *wrapperInstance = new AppBroadcastStreamReader(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::Media::Capture::AppBroadcastStreamReader^>(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::Media::Capture::AppBroadcastStreamReader^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppBroadcastStreamReader^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppBroadcastStreamReader(winRtInstance));
    }


    static void TryGetNextAudioFrame(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamReader^>(info.This())) {
        return;
      }

      AppBroadcastStreamReader *wrapper = AppBroadcastStreamReader::Unwrap<AppBroadcastStreamReader>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Media::Capture::AppBroadcastStreamAudioFrame^ result;
          result = wrapper->_instance->TryGetNextAudioFrame();
          info.GetReturnValue().Set(WrapAppBroadcastStreamAudioFrame(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 TryGetNextVideoFrame(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamReader^>(info.This())) {
        return;
      }

      AppBroadcastStreamReader *wrapper = AppBroadcastStreamReader::Unwrap<AppBroadcastStreamReader>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Media::Capture::AppBroadcastStreamVideoFrame^ result;
          result = wrapper->_instance->TryGetNextVideoFrame();
          info.GetReturnValue().Set(WrapAppBroadcastStreamVideoFrame(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 AudioAacSequenceGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamReader^>(info.This())) {
        return;
      }

      AppBroadcastStreamReader *wrapper = AppBroadcastStreamReader::Unwrap<AppBroadcastStreamReader>(info.This());

      try  {
        ::Windows::Storage::Streams::IBuffer^ result = wrapper->_instance->AudioAacSequence;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Storage.Streams", "IBuffer", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AudioBitrateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamReader^>(info.This())) {
        return;
      }

      AppBroadcastStreamReader *wrapper = AppBroadcastStreamReader::Unwrap<AppBroadcastStreamReader>(info.This());

      try  {
        unsigned int result = wrapper->_instance->AudioBitrate;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AudioChannelsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamReader^>(info.This())) {
        return;
      }

      AppBroadcastStreamReader *wrapper = AppBroadcastStreamReader::Unwrap<AppBroadcastStreamReader>(info.This());

      try  {
        unsigned int result = wrapper->_instance->AudioChannels;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AudioSampleRateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamReader^>(info.This())) {
        return;
      }

      AppBroadcastStreamReader *wrapper = AppBroadcastStreamReader::Unwrap<AppBroadcastStreamReader>(info.This());

      try  {
        unsigned int result = wrapper->_instance->AudioSampleRate;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VideoBitrateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamReader^>(info.This())) {
        return;
      }

      AppBroadcastStreamReader *wrapper = AppBroadcastStreamReader::Unwrap<AppBroadcastStreamReader>(info.This());

      try  {
        unsigned int result = wrapper->_instance->VideoBitrate;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VideoHeightGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamReader^>(info.This())) {
        return;
      }

      AppBroadcastStreamReader *wrapper = AppBroadcastStreamReader::Unwrap<AppBroadcastStreamReader>(info.This());

      try  {
        unsigned int result = wrapper->_instance->VideoHeight;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VideoWidthGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamReader^>(info.This())) {
        return;
      }

      AppBroadcastStreamReader *wrapper = AppBroadcastStreamReader::Unwrap<AppBroadcastStreamReader>(info.This());

      try  {
        unsigned int result = wrapper->_instance->VideoWidth;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    static void AddListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"audioFrameArrived", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamReader^>(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;
        }
        AppBroadcastStreamReader *wrapper = AppBroadcastStreamReader::Unwrap<AppBroadcastStreamReader>(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->AudioFrameArrived::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::AppBroadcastStreamReader^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Media::Capture::AppBroadcastStreamReader^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAppBroadcastStreamReader(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"videoFrameArrived", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamReader^>(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;
        }
        AppBroadcastStreamReader *wrapper = AppBroadcastStreamReader::Unwrap<AppBroadcastStreamReader>(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->VideoFrameArrived::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::AppBroadcastStreamReader^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Media::Capture::AppBroadcastStreamReader^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAppBroadcastStreamReader(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"audioFrameArrived", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"videoFrameArrived", 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"audioFrameArrived", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamReader^>(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;
          }
          AppBroadcastStreamReader *wrapper = AppBroadcastStreamReader::Unwrap<AppBroadcastStreamReader>(info.This());
          wrapper->_instance->AudioFrameArrived::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"videoFrameArrived", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamReader^>(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;
          }
          AppBroadcastStreamReader *wrapper = AppBroadcastStreamReader::Unwrap<AppBroadcastStreamReader>(info.This());
          wrapper->_instance->VideoFrameArrived::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::Media::Capture::AppBroadcastStreamReader^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppBroadcastStreamReader(::Windows::Media::Capture::AppBroadcastStreamReader^ wintRtInstance);
      friend ::Windows::Media::Capture::AppBroadcastStreamReader^ UnwrapAppBroadcastStreamReader(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppBroadcastStreamReader::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppBroadcastStreamReader(::Windows::Media::Capture::AppBroadcastStreamReader^ 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>(AppBroadcastStreamReader::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppBroadcastStreamReader^ UnwrapAppBroadcastStreamReader(Local<Value> value) {
     return AppBroadcastStreamReader::Unwrap<AppBroadcastStreamReader>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppBroadcastStreamReader(Local<Object> exports) {
    AppBroadcastStreamReader::Init(exports);
  }

  class AppBroadcastBackgroundServiceStreamInfo : 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>("AppBroadcastBackgroundServiceStreamInfo").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>("desiredVideoEncodingBitrate").ToLocalChecked(), DesiredVideoEncodingBitrateGetter, DesiredVideoEncodingBitrateSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("bandwidthTestBitrate").ToLocalChecked(), BandwidthTestBitrateGetter, BandwidthTestBitrateSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("audioCodec").ToLocalChecked(), AudioCodecGetter, AudioCodecSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("broadcastStreamReader").ToLocalChecked(), BroadcastStreamReaderGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("streamState").ToLocalChecked(), StreamStateGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppBroadcastBackgroundServiceStreamInfo").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppBroadcastBackgroundServiceStreamInfo(::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^ 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::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^) 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());

      AppBroadcastBackgroundServiceStreamInfo *wrapperInstance = new AppBroadcastBackgroundServiceStreamInfo(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::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^>(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::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppBroadcastBackgroundServiceStreamInfo(winRtInstance));
    }





    static void DesiredVideoEncodingBitrateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^>(info.This())) {
        return;
      }

      AppBroadcastBackgroundServiceStreamInfo *wrapper = AppBroadcastBackgroundServiceStreamInfo::Unwrap<AppBroadcastBackgroundServiceStreamInfo>(info.This());

      try  {
        unsigned __int64 result = wrapper->_instance->DesiredVideoEncodingBitrate;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DesiredVideoEncodingBitrateSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^>(info.This())) {
        return;
      }

      AppBroadcastBackgroundServiceStreamInfo *wrapper = AppBroadcastBackgroundServiceStreamInfo::Unwrap<AppBroadcastBackgroundServiceStreamInfo>(info.This());

      try {

        unsigned __int64 winRtValue = static_cast<unsigned __int64>(Nan::To<int64_t>(value).FromMaybe(0));

        wrapper->_instance->DesiredVideoEncodingBitrate = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void BandwidthTestBitrateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^>(info.This())) {
        return;
      }

      AppBroadcastBackgroundServiceStreamInfo *wrapper = AppBroadcastBackgroundServiceStreamInfo::Unwrap<AppBroadcastBackgroundServiceStreamInfo>(info.This());

      try  {
        unsigned __int64 result = wrapper->_instance->BandwidthTestBitrate;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BandwidthTestBitrateSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^>(info.This())) {
        return;
      }

      AppBroadcastBackgroundServiceStreamInfo *wrapper = AppBroadcastBackgroundServiceStreamInfo::Unwrap<AppBroadcastBackgroundServiceStreamInfo>(info.This());

      try {

        unsigned __int64 winRtValue = static_cast<unsigned __int64>(Nan::To<int64_t>(value).FromMaybe(0));

        wrapper->_instance->BandwidthTestBitrate = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void AudioCodecGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^>(info.This())) {
        return;
      }

      AppBroadcastBackgroundServiceStreamInfo *wrapper = AppBroadcastBackgroundServiceStreamInfo::Unwrap<AppBroadcastBackgroundServiceStreamInfo>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->AudioCodec;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AudioCodecSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsString()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^>(info.This())) {
        return;
      }

      AppBroadcastBackgroundServiceStreamInfo *wrapper = AppBroadcastBackgroundServiceStreamInfo::Unwrap<AppBroadcastBackgroundServiceStreamInfo>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->AudioCodec = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void BroadcastStreamReaderGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^>(info.This())) {
        return;
      }

      AppBroadcastBackgroundServiceStreamInfo *wrapper = AppBroadcastBackgroundServiceStreamInfo::Unwrap<AppBroadcastBackgroundServiceStreamInfo>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastStreamReader^ result = wrapper->_instance->BroadcastStreamReader;
        info.GetReturnValue().Set(WrapAppBroadcastStreamReader(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void StreamStateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^>(info.This())) {
        return;
      }

      AppBroadcastBackgroundServiceStreamInfo *wrapper = AppBroadcastBackgroundServiceStreamInfo::Unwrap<AppBroadcastBackgroundServiceStreamInfo>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastStreamState result = wrapper->_instance->StreamState;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    static void AddListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"streamStateChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^>(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;
        }
        AppBroadcastBackgroundServiceStreamInfo *wrapper = AppBroadcastBackgroundServiceStreamInfo::Unwrap<AppBroadcastBackgroundServiceStreamInfo>(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->StreamStateChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^, ::Windows::Media::Capture::AppBroadcastStreamStateChangedEventArgs^>(
            [callbackObjPtr](::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^ arg0, ::Windows::Media::Capture::AppBroadcastStreamStateChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAppBroadcastBackgroundServiceStreamInfo(arg0);
                  wrappedArg1 = WrapAppBroadcastStreamStateChangedEventArgs(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"videoEncodingBitrateChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^>(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;
        }
        AppBroadcastBackgroundServiceStreamInfo *wrapper = AppBroadcastBackgroundServiceStreamInfo::Unwrap<AppBroadcastBackgroundServiceStreamInfo>(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->VideoEncodingBitrateChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAppBroadcastBackgroundServiceStreamInfo(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"videoEncodingResolutionChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^>(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;
        }
        AppBroadcastBackgroundServiceStreamInfo *wrapper = AppBroadcastBackgroundServiceStreamInfo::Unwrap<AppBroadcastBackgroundServiceStreamInfo>(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->VideoEncodingResolutionChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAppBroadcastBackgroundServiceStreamInfo(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"streamStateChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"videoEncodingBitrateChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"videoEncodingResolutionChanged", 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"streamStateChanged", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^>(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;
          }
          AppBroadcastBackgroundServiceStreamInfo *wrapper = AppBroadcastBackgroundServiceStreamInfo::Unwrap<AppBroadcastBackgroundServiceStreamInfo>(info.This());
          wrapper->_instance->StreamStateChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"videoEncodingBitrateChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^>(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;
          }
          AppBroadcastBackgroundServiceStreamInfo *wrapper = AppBroadcastBackgroundServiceStreamInfo::Unwrap<AppBroadcastBackgroundServiceStreamInfo>(info.This());
          wrapper->_instance->VideoEncodingBitrateChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"videoEncodingResolutionChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^>(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;
          }
          AppBroadcastBackgroundServiceStreamInfo *wrapper = AppBroadcastBackgroundServiceStreamInfo::Unwrap<AppBroadcastBackgroundServiceStreamInfo>(info.This());
          wrapper->_instance->VideoEncodingResolutionChanged::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::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppBroadcastBackgroundServiceStreamInfo(::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^ wintRtInstance);
      friend ::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^ UnwrapAppBroadcastBackgroundServiceStreamInfo(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppBroadcastBackgroundServiceStreamInfo::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppBroadcastBackgroundServiceStreamInfo(::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^ 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>(AppBroadcastBackgroundServiceStreamInfo::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^ UnwrapAppBroadcastBackgroundServiceStreamInfo(Local<Value> value) {
     return AppBroadcastBackgroundServiceStreamInfo::Unwrap<AppBroadcastBackgroundServiceStreamInfo>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppBroadcastBackgroundServiceStreamInfo(Local<Object> exports) {
    AppBroadcastBackgroundServiceStreamInfo::Init(exports);
  }

  class AppBroadcastStreamStateChangedEventArgs : 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>("AppBroadcastStreamStateChangedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("streamState").ToLocalChecked(), StreamStateGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppBroadcastStreamStateChangedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppBroadcastStreamStateChangedEventArgs(::Windows::Media::Capture::AppBroadcastStreamStateChangedEventArgs^ 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::Media::Capture::AppBroadcastStreamStateChangedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamStateChangedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppBroadcastStreamStateChangedEventArgs^) 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());

      AppBroadcastStreamStateChangedEventArgs *wrapperInstance = new AppBroadcastStreamStateChangedEventArgs(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::Media::Capture::AppBroadcastStreamStateChangedEventArgs^>(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::Media::Capture::AppBroadcastStreamStateChangedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppBroadcastStreamStateChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppBroadcastStreamStateChangedEventArgs(winRtInstance));
    }





    static void StreamStateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamStateChangedEventArgs^>(info.This())) {
        return;
      }

      AppBroadcastStreamStateChangedEventArgs *wrapper = AppBroadcastStreamStateChangedEventArgs::Unwrap<AppBroadcastStreamStateChangedEventArgs>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastStreamState result = wrapper->_instance->StreamState;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::AppBroadcastStreamStateChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppBroadcastStreamStateChangedEventArgs(::Windows::Media::Capture::AppBroadcastStreamStateChangedEventArgs^ wintRtInstance);
      friend ::Windows::Media::Capture::AppBroadcastStreamStateChangedEventArgs^ UnwrapAppBroadcastStreamStateChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppBroadcastStreamStateChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppBroadcastStreamStateChangedEventArgs(::Windows::Media::Capture::AppBroadcastStreamStateChangedEventArgs^ 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>(AppBroadcastStreamStateChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppBroadcastStreamStateChangedEventArgs^ UnwrapAppBroadcastStreamStateChangedEventArgs(Local<Value> value) {
     return AppBroadcastStreamStateChangedEventArgs::Unwrap<AppBroadcastStreamStateChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppBroadcastStreamStateChangedEventArgs(Local<Object> exports) {
    AppBroadcastStreamStateChangedEventArgs::Init(exports);
  }

  class AppBroadcastBackgroundService : 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>("AppBroadcastBackgroundService").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "terminateBroadcast", TerminateBroadcast);
          


          
          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>("viewerCount").ToLocalChecked(), ViewerCountGetter, ViewerCountSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("streamInfo").ToLocalChecked(), StreamInfoGetter, StreamInfoSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("signInInfo").ToLocalChecked(), SignInInfoGetter, SignInInfoSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("plugInState").ToLocalChecked(), PlugInStateGetter, PlugInStateSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("appId").ToLocalChecked(), AppIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("broadcastTitle").ToLocalChecked(), BroadcastTitleGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("titleId").ToLocalChecked(), TitleIdGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppBroadcastBackgroundService").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppBroadcastBackgroundService(::Windows::Media::Capture::AppBroadcastBackgroundService^ 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::Media::Capture::AppBroadcastBackgroundService^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundService^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppBroadcastBackgroundService^) 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());

      AppBroadcastBackgroundService *wrapperInstance = new AppBroadcastBackgroundService(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::Media::Capture::AppBroadcastBackgroundService^>(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::Media::Capture::AppBroadcastBackgroundService^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppBroadcastBackgroundService^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppBroadcastBackgroundService(winRtInstance));
    }


    static void TerminateBroadcast(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundService^>(info.This())) {
        return;
      }

      AppBroadcastBackgroundService *wrapper = AppBroadcastBackgroundService::Unwrap<AppBroadcastBackgroundService>(info.This());

      if (info.Length() == 2
        && info[0]->IsInt32()
        && info[1]->IsUint32())
      {
        try
        {
          ::Windows::Media::Capture::AppBroadcastTerminationReason arg0 = static_cast<::Windows::Media::Capture::AppBroadcastTerminationReason>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          unsigned int arg1 = static_cast<unsigned int>(Nan::To<uint32_t>(info[1]).FromMaybe(0));
          
          wrapper->_instance->TerminateBroadcast(arg0, arg1);
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    static void ViewerCountGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundService^>(info.This())) {
        return;
      }

      AppBroadcastBackgroundService *wrapper = AppBroadcastBackgroundService::Unwrap<AppBroadcastBackgroundService>(info.This());

      try  {
        unsigned int result = wrapper->_instance->ViewerCount;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ViewerCountSetter(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::Media::Capture::AppBroadcastBackgroundService^>(info.This())) {
        return;
      }

      AppBroadcastBackgroundService *wrapper = AppBroadcastBackgroundService::Unwrap<AppBroadcastBackgroundService>(info.This());

      try {

        unsigned int winRtValue = static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));

        wrapper->_instance->ViewerCount = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void StreamInfoGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundService^>(info.This())) {
        return;
      }

      AppBroadcastBackgroundService *wrapper = AppBroadcastBackgroundService::Unwrap<AppBroadcastBackgroundService>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^ result = wrapper->_instance->StreamInfo;
        info.GetReturnValue().Set(WrapAppBroadcastBackgroundServiceStreamInfo(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void StreamInfoSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundService^>(info.This())) {
        return;
      }

      AppBroadcastBackgroundService *wrapper = AppBroadcastBackgroundService::Unwrap<AppBroadcastBackgroundService>(info.This());

      try {

        ::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^ winRtValue = dynamic_cast<::Windows::Media::Capture::AppBroadcastBackgroundServiceStreamInfo^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->StreamInfo = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void SignInInfoGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundService^>(info.This())) {
        return;
      }

      AppBroadcastBackgroundService *wrapper = AppBroadcastBackgroundService::Unwrap<AppBroadcastBackgroundService>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^ result = wrapper->_instance->SignInInfo;
        info.GetReturnValue().Set(WrapAppBroadcastBackgroundServiceSignInInfo(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SignInInfoSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundService^>(info.This())) {
        return;
      }

      AppBroadcastBackgroundService *wrapper = AppBroadcastBackgroundService::Unwrap<AppBroadcastBackgroundService>(info.This());

      try {

        ::Windows::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^ winRtValue = dynamic_cast<::Windows::Media::Capture::AppBroadcastBackgroundServiceSignInInfo^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->SignInInfo = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void PlugInStateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundService^>(info.This())) {
        return;
      }

      AppBroadcastBackgroundService *wrapper = AppBroadcastBackgroundService::Unwrap<AppBroadcastBackgroundService>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastPlugInState result = wrapper->_instance->PlugInState;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PlugInStateSetter(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::Media::Capture::AppBroadcastBackgroundService^>(info.This())) {
        return;
      }

      AppBroadcastBackgroundService *wrapper = AppBroadcastBackgroundService::Unwrap<AppBroadcastBackgroundService>(info.This());

      try {

        ::Windows::Media::Capture::AppBroadcastPlugInState winRtValue = static_cast<::Windows::Media::Capture::AppBroadcastPlugInState>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->PlugInState = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void AppIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundService^>(info.This())) {
        return;
      }

      AppBroadcastBackgroundService *wrapper = AppBroadcastBackgroundService::Unwrap<AppBroadcastBackgroundService>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->AppId;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BroadcastTitleGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundService^>(info.This())) {
        return;
      }

      AppBroadcastBackgroundService *wrapper = AppBroadcastBackgroundService::Unwrap<AppBroadcastBackgroundService>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->BroadcastTitle;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TitleIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundService^>(info.This())) {
        return;
      }

      AppBroadcastBackgroundService *wrapper = AppBroadcastBackgroundService::Unwrap<AppBroadcastBackgroundService>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->TitleId;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    static void AddListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"heartbeatRequested", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundService^>(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;
        }
        AppBroadcastBackgroundService *wrapper = AppBroadcastBackgroundService::Unwrap<AppBroadcastBackgroundService>(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->HeartbeatRequested::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::AppBroadcastBackgroundService^, ::Windows::Media::Capture::AppBroadcastHeartbeatRequestedEventArgs^>(
            [callbackObjPtr](::Windows::Media::Capture::AppBroadcastBackgroundService^ arg0, ::Windows::Media::Capture::AppBroadcastHeartbeatRequestedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAppBroadcastBackgroundService(arg0);
                  wrappedArg1 = WrapAppBroadcastHeartbeatRequestedEventArgs(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"heartbeatRequested", 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"heartbeatRequested", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastBackgroundService^>(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;
          }
          AppBroadcastBackgroundService *wrapper = AppBroadcastBackgroundService::Unwrap<AppBroadcastBackgroundService>(info.This());
          wrapper->_instance->HeartbeatRequested::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::Media::Capture::AppBroadcastBackgroundService^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppBroadcastBackgroundService(::Windows::Media::Capture::AppBroadcastBackgroundService^ wintRtInstance);
      friend ::Windows::Media::Capture::AppBroadcastBackgroundService^ UnwrapAppBroadcastBackgroundService(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppBroadcastBackgroundService::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppBroadcastBackgroundService(::Windows::Media::Capture::AppBroadcastBackgroundService^ 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>(AppBroadcastBackgroundService::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppBroadcastBackgroundService^ UnwrapAppBroadcastBackgroundService(Local<Value> value) {
     return AppBroadcastBackgroundService::Unwrap<AppBroadcastBackgroundService>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppBroadcastBackgroundService(Local<Object> exports) {
    AppBroadcastBackgroundService::Init(exports);
  }

  class AppBroadcastHeartbeatRequestedEventArgs : 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>("AppBroadcastHeartbeatRequestedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("handled").ToLocalChecked(), HandledGetter, HandledSetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppBroadcastHeartbeatRequestedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppBroadcastHeartbeatRequestedEventArgs(::Windows::Media::Capture::AppBroadcastHeartbeatRequestedEventArgs^ 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::Media::Capture::AppBroadcastHeartbeatRequestedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastHeartbeatRequestedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppBroadcastHeartbeatRequestedEventArgs^) 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());

      AppBroadcastHeartbeatRequestedEventArgs *wrapperInstance = new AppBroadcastHeartbeatRequestedEventArgs(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::Media::Capture::AppBroadcastHeartbeatRequestedEventArgs^>(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::Media::Capture::AppBroadcastHeartbeatRequestedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppBroadcastHeartbeatRequestedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppBroadcastHeartbeatRequestedEventArgs(winRtInstance));
    }





    static void HandledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastHeartbeatRequestedEventArgs^>(info.This())) {
        return;
      }

      AppBroadcastHeartbeatRequestedEventArgs *wrapper = AppBroadcastHeartbeatRequestedEventArgs::Unwrap<AppBroadcastHeartbeatRequestedEventArgs>(info.This());

      try  {
        bool result = wrapper->_instance->Handled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void HandledSetter(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::Media::Capture::AppBroadcastHeartbeatRequestedEventArgs^>(info.This())) {
        return;
      }

      AppBroadcastHeartbeatRequestedEventArgs *wrapper = AppBroadcastHeartbeatRequestedEventArgs::Unwrap<AppBroadcastHeartbeatRequestedEventArgs>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->Handled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      


    private:
      ::Windows::Media::Capture::AppBroadcastHeartbeatRequestedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppBroadcastHeartbeatRequestedEventArgs(::Windows::Media::Capture::AppBroadcastHeartbeatRequestedEventArgs^ wintRtInstance);
      friend ::Windows::Media::Capture::AppBroadcastHeartbeatRequestedEventArgs^ UnwrapAppBroadcastHeartbeatRequestedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppBroadcastHeartbeatRequestedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppBroadcastHeartbeatRequestedEventArgs(::Windows::Media::Capture::AppBroadcastHeartbeatRequestedEventArgs^ 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>(AppBroadcastHeartbeatRequestedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppBroadcastHeartbeatRequestedEventArgs^ UnwrapAppBroadcastHeartbeatRequestedEventArgs(Local<Value> value) {
     return AppBroadcastHeartbeatRequestedEventArgs::Unwrap<AppBroadcastHeartbeatRequestedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppBroadcastHeartbeatRequestedEventArgs(Local<Object> exports) {
    AppBroadcastHeartbeatRequestedEventArgs::Init(exports);
  }

  class AppBroadcastStreamAudioFrame : 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>("AppBroadcastStreamAudioFrame").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("audioBuffer").ToLocalChecked(), AudioBufferGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("audioHeader").ToLocalChecked(), AudioHeaderGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppBroadcastStreamAudioFrame").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppBroadcastStreamAudioFrame(::Windows::Media::Capture::AppBroadcastStreamAudioFrame^ 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::Media::Capture::AppBroadcastStreamAudioFrame^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamAudioFrame^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppBroadcastStreamAudioFrame^) 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());

      AppBroadcastStreamAudioFrame *wrapperInstance = new AppBroadcastStreamAudioFrame(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::Media::Capture::AppBroadcastStreamAudioFrame^>(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::Media::Capture::AppBroadcastStreamAudioFrame^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppBroadcastStreamAudioFrame^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppBroadcastStreamAudioFrame(winRtInstance));
    }





    static void AudioBufferGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamAudioFrame^>(info.This())) {
        return;
      }

      AppBroadcastStreamAudioFrame *wrapper = AppBroadcastStreamAudioFrame::Unwrap<AppBroadcastStreamAudioFrame>(info.This());

      try  {
        ::Windows::Storage::Streams::IBuffer^ result = wrapper->_instance->AudioBuffer;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Storage.Streams", "IBuffer", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AudioHeaderGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamAudioFrame^>(info.This())) {
        return;
      }

      AppBroadcastStreamAudioFrame *wrapper = AppBroadcastStreamAudioFrame::Unwrap<AppBroadcastStreamAudioFrame>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastStreamAudioHeader^ result = wrapper->_instance->AudioHeader;
        info.GetReturnValue().Set(WrapAppBroadcastStreamAudioHeader(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::AppBroadcastStreamAudioFrame^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppBroadcastStreamAudioFrame(::Windows::Media::Capture::AppBroadcastStreamAudioFrame^ wintRtInstance);
      friend ::Windows::Media::Capture::AppBroadcastStreamAudioFrame^ UnwrapAppBroadcastStreamAudioFrame(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppBroadcastStreamAudioFrame::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppBroadcastStreamAudioFrame(::Windows::Media::Capture::AppBroadcastStreamAudioFrame^ 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>(AppBroadcastStreamAudioFrame::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppBroadcastStreamAudioFrame^ UnwrapAppBroadcastStreamAudioFrame(Local<Value> value) {
     return AppBroadcastStreamAudioFrame::Unwrap<AppBroadcastStreamAudioFrame>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppBroadcastStreamAudioFrame(Local<Object> exports) {
    AppBroadcastStreamAudioFrame::Init(exports);
  }

  class AppBroadcastStreamVideoFrame : 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>("AppBroadcastStreamVideoFrame").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoBuffer").ToLocalChecked(), VideoBufferGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoHeader").ToLocalChecked(), VideoHeaderGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppBroadcastStreamVideoFrame").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppBroadcastStreamVideoFrame(::Windows::Media::Capture::AppBroadcastStreamVideoFrame^ 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::Media::Capture::AppBroadcastStreamVideoFrame^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamVideoFrame^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppBroadcastStreamVideoFrame^) 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());

      AppBroadcastStreamVideoFrame *wrapperInstance = new AppBroadcastStreamVideoFrame(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::Media::Capture::AppBroadcastStreamVideoFrame^>(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::Media::Capture::AppBroadcastStreamVideoFrame^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppBroadcastStreamVideoFrame^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppBroadcastStreamVideoFrame(winRtInstance));
    }





    static void VideoBufferGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamVideoFrame^>(info.This())) {
        return;
      }

      AppBroadcastStreamVideoFrame *wrapper = AppBroadcastStreamVideoFrame::Unwrap<AppBroadcastStreamVideoFrame>(info.This());

      try  {
        ::Windows::Storage::Streams::IBuffer^ result = wrapper->_instance->VideoBuffer;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Storage.Streams", "IBuffer", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VideoHeaderGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamVideoFrame^>(info.This())) {
        return;
      }

      AppBroadcastStreamVideoFrame *wrapper = AppBroadcastStreamVideoFrame::Unwrap<AppBroadcastStreamVideoFrame>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastStreamVideoHeader^ result = wrapper->_instance->VideoHeader;
        info.GetReturnValue().Set(WrapAppBroadcastStreamVideoHeader(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::AppBroadcastStreamVideoFrame^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppBroadcastStreamVideoFrame(::Windows::Media::Capture::AppBroadcastStreamVideoFrame^ wintRtInstance);
      friend ::Windows::Media::Capture::AppBroadcastStreamVideoFrame^ UnwrapAppBroadcastStreamVideoFrame(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppBroadcastStreamVideoFrame::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppBroadcastStreamVideoFrame(::Windows::Media::Capture::AppBroadcastStreamVideoFrame^ 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>(AppBroadcastStreamVideoFrame::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppBroadcastStreamVideoFrame^ UnwrapAppBroadcastStreamVideoFrame(Local<Value> value) {
     return AppBroadcastStreamVideoFrame::Unwrap<AppBroadcastStreamVideoFrame>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppBroadcastStreamVideoFrame(Local<Object> exports) {
    AppBroadcastStreamVideoFrame::Init(exports);
  }

  class AppBroadcastStreamVideoHeader : 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>("AppBroadcastStreamVideoHeader").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("absoluteTimestamp").ToLocalChecked(), AbsoluteTimestampGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("duration").ToLocalChecked(), DurationGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("frameId").ToLocalChecked(), FrameIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("hasDiscontinuity").ToLocalChecked(), HasDiscontinuityGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isKeyFrame").ToLocalChecked(), IsKeyFrameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("relativeTimestamp").ToLocalChecked(), RelativeTimestampGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppBroadcastStreamVideoHeader").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppBroadcastStreamVideoHeader(::Windows::Media::Capture::AppBroadcastStreamVideoHeader^ 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::Media::Capture::AppBroadcastStreamVideoHeader^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamVideoHeader^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppBroadcastStreamVideoHeader^) 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());

      AppBroadcastStreamVideoHeader *wrapperInstance = new AppBroadcastStreamVideoHeader(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::Media::Capture::AppBroadcastStreamVideoHeader^>(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::Media::Capture::AppBroadcastStreamVideoHeader^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppBroadcastStreamVideoHeader^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppBroadcastStreamVideoHeader(winRtInstance));
    }





    static void AbsoluteTimestampGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamVideoHeader^>(info.This())) {
        return;
      }

      AppBroadcastStreamVideoHeader *wrapper = AppBroadcastStreamVideoHeader::Unwrap<AppBroadcastStreamVideoHeader>(info.This());

      try  {
        ::Windows::Foundation::DateTime result = wrapper->_instance->AbsoluteTimestamp;
        info.GetReturnValue().Set(NodeRT::Utils::DateTimeToJS(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DurationGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamVideoHeader^>(info.This())) {
        return;
      }

      AppBroadcastStreamVideoHeader *wrapper = AppBroadcastStreamVideoHeader::Unwrap<AppBroadcastStreamVideoHeader>(info.This());

      try  {
        ::Windows::Foundation::TimeSpan result = wrapper->_instance->Duration;
        info.GetReturnValue().Set(Nan::New<Number>(result.Duration/10000.0));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void FrameIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamVideoHeader^>(info.This())) {
        return;
      }

      AppBroadcastStreamVideoHeader *wrapper = AppBroadcastStreamVideoHeader::Unwrap<AppBroadcastStreamVideoHeader>(info.This());

      try  {
        unsigned __int64 result = wrapper->_instance->FrameId;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void HasDiscontinuityGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamVideoHeader^>(info.This())) {
        return;
      }

      AppBroadcastStreamVideoHeader *wrapper = AppBroadcastStreamVideoHeader::Unwrap<AppBroadcastStreamVideoHeader>(info.This());

      try  {
        bool result = wrapper->_instance->HasDiscontinuity;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsKeyFrameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamVideoHeader^>(info.This())) {
        return;
      }

      AppBroadcastStreamVideoHeader *wrapper = AppBroadcastStreamVideoHeader::Unwrap<AppBroadcastStreamVideoHeader>(info.This());

      try  {
        bool result = wrapper->_instance->IsKeyFrame;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RelativeTimestampGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamVideoHeader^>(info.This())) {
        return;
      }

      AppBroadcastStreamVideoHeader *wrapper = AppBroadcastStreamVideoHeader::Unwrap<AppBroadcastStreamVideoHeader>(info.This());

      try  {
        ::Windows::Foundation::TimeSpan result = wrapper->_instance->RelativeTimestamp;
        info.GetReturnValue().Set(Nan::New<Number>(result.Duration/10000.0));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::AppBroadcastStreamVideoHeader^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppBroadcastStreamVideoHeader(::Windows::Media::Capture::AppBroadcastStreamVideoHeader^ wintRtInstance);
      friend ::Windows::Media::Capture::AppBroadcastStreamVideoHeader^ UnwrapAppBroadcastStreamVideoHeader(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppBroadcastStreamVideoHeader::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppBroadcastStreamVideoHeader(::Windows::Media::Capture::AppBroadcastStreamVideoHeader^ 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>(AppBroadcastStreamVideoHeader::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppBroadcastStreamVideoHeader^ UnwrapAppBroadcastStreamVideoHeader(Local<Value> value) {
     return AppBroadcastStreamVideoHeader::Unwrap<AppBroadcastStreamVideoHeader>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppBroadcastStreamVideoHeader(Local<Object> exports) {
    AppBroadcastStreamVideoHeader::Init(exports);
  }

  class AppBroadcastStreamAudioHeader : 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>("AppBroadcastStreamAudioHeader").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("absoluteTimestamp").ToLocalChecked(), AbsoluteTimestampGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("duration").ToLocalChecked(), DurationGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("frameId").ToLocalChecked(), FrameIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("hasDiscontinuity").ToLocalChecked(), HasDiscontinuityGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("relativeTimestamp").ToLocalChecked(), RelativeTimestampGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppBroadcastStreamAudioHeader").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppBroadcastStreamAudioHeader(::Windows::Media::Capture::AppBroadcastStreamAudioHeader^ 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::Media::Capture::AppBroadcastStreamAudioHeader^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamAudioHeader^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppBroadcastStreamAudioHeader^) 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());

      AppBroadcastStreamAudioHeader *wrapperInstance = new AppBroadcastStreamAudioHeader(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::Media::Capture::AppBroadcastStreamAudioHeader^>(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::Media::Capture::AppBroadcastStreamAudioHeader^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppBroadcastStreamAudioHeader^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppBroadcastStreamAudioHeader(winRtInstance));
    }





    static void AbsoluteTimestampGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamAudioHeader^>(info.This())) {
        return;
      }

      AppBroadcastStreamAudioHeader *wrapper = AppBroadcastStreamAudioHeader::Unwrap<AppBroadcastStreamAudioHeader>(info.This());

      try  {
        ::Windows::Foundation::DateTime result = wrapper->_instance->AbsoluteTimestamp;
        info.GetReturnValue().Set(NodeRT::Utils::DateTimeToJS(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DurationGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamAudioHeader^>(info.This())) {
        return;
      }

      AppBroadcastStreamAudioHeader *wrapper = AppBroadcastStreamAudioHeader::Unwrap<AppBroadcastStreamAudioHeader>(info.This());

      try  {
        ::Windows::Foundation::TimeSpan result = wrapper->_instance->Duration;
        info.GetReturnValue().Set(Nan::New<Number>(result.Duration/10000.0));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void FrameIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamAudioHeader^>(info.This())) {
        return;
      }

      AppBroadcastStreamAudioHeader *wrapper = AppBroadcastStreamAudioHeader::Unwrap<AppBroadcastStreamAudioHeader>(info.This());

      try  {
        unsigned __int64 result = wrapper->_instance->FrameId;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void HasDiscontinuityGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamAudioHeader^>(info.This())) {
        return;
      }

      AppBroadcastStreamAudioHeader *wrapper = AppBroadcastStreamAudioHeader::Unwrap<AppBroadcastStreamAudioHeader>(info.This());

      try  {
        bool result = wrapper->_instance->HasDiscontinuity;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RelativeTimestampGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastStreamAudioHeader^>(info.This())) {
        return;
      }

      AppBroadcastStreamAudioHeader *wrapper = AppBroadcastStreamAudioHeader::Unwrap<AppBroadcastStreamAudioHeader>(info.This());

      try  {
        ::Windows::Foundation::TimeSpan result = wrapper->_instance->RelativeTimestamp;
        info.GetReturnValue().Set(Nan::New<Number>(result.Duration/10000.0));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::AppBroadcastStreamAudioHeader^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppBroadcastStreamAudioHeader(::Windows::Media::Capture::AppBroadcastStreamAudioHeader^ wintRtInstance);
      friend ::Windows::Media::Capture::AppBroadcastStreamAudioHeader^ UnwrapAppBroadcastStreamAudioHeader(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppBroadcastStreamAudioHeader::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppBroadcastStreamAudioHeader(::Windows::Media::Capture::AppBroadcastStreamAudioHeader^ 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>(AppBroadcastStreamAudioHeader::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppBroadcastStreamAudioHeader^ UnwrapAppBroadcastStreamAudioHeader(Local<Value> value) {
     return AppBroadcastStreamAudioHeader::Unwrap<AppBroadcastStreamAudioHeader>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppBroadcastStreamAudioHeader(Local<Object> exports) {
    AppBroadcastStreamAudioHeader::Init(exports);
  }

  class AppBroadcastTriggerDetails : 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>("AppBroadcastTriggerDetails").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("backgroundService").ToLocalChecked(), BackgroundServiceGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppBroadcastTriggerDetails").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppBroadcastTriggerDetails(::Windows::Media::Capture::AppBroadcastTriggerDetails^ 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::Media::Capture::AppBroadcastTriggerDetails^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastTriggerDetails^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppBroadcastTriggerDetails^) 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());

      AppBroadcastTriggerDetails *wrapperInstance = new AppBroadcastTriggerDetails(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::Media::Capture::AppBroadcastTriggerDetails^>(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::Media::Capture::AppBroadcastTriggerDetails^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppBroadcastTriggerDetails^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppBroadcastTriggerDetails(winRtInstance));
    }





    static void BackgroundServiceGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastTriggerDetails^>(info.This())) {
        return;
      }

      AppBroadcastTriggerDetails *wrapper = AppBroadcastTriggerDetails::Unwrap<AppBroadcastTriggerDetails>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastBackgroundService^ result = wrapper->_instance->BackgroundService;
        info.GetReturnValue().Set(WrapAppBroadcastBackgroundService(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::AppBroadcastTriggerDetails^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppBroadcastTriggerDetails(::Windows::Media::Capture::AppBroadcastTriggerDetails^ wintRtInstance);
      friend ::Windows::Media::Capture::AppBroadcastTriggerDetails^ UnwrapAppBroadcastTriggerDetails(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppBroadcastTriggerDetails::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppBroadcastTriggerDetails(::Windows::Media::Capture::AppBroadcastTriggerDetails^ 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>(AppBroadcastTriggerDetails::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppBroadcastTriggerDetails^ UnwrapAppBroadcastTriggerDetails(Local<Value> value) {
     return AppBroadcastTriggerDetails::Unwrap<AppBroadcastTriggerDetails>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppBroadcastTriggerDetails(Local<Object> exports) {
    AppBroadcastTriggerDetails::Init(exports);
  }

  class AppBroadcastPlugInManager : 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>("AppBroadcastPlugInManager").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("defaultPlugIn").ToLocalChecked(), DefaultPlugInGetter, DefaultPlugInSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isBroadcastProviderAvailable").ToLocalChecked(), IsBroadcastProviderAvailableGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("plugInList").ToLocalChecked(), PlugInListGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetMethod(constructor, "getDefault", GetDefault);
        Nan::SetMethod(constructor, "getForUser", GetForUser);


        Nan::Set(exports, Nan::New<String>("AppBroadcastPlugInManager").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppBroadcastPlugInManager(::Windows::Media::Capture::AppBroadcastPlugInManager^ 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::Media::Capture::AppBroadcastPlugInManager^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPlugInManager^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppBroadcastPlugInManager^) 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());

      AppBroadcastPlugInManager *wrapperInstance = new AppBroadcastPlugInManager(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::Media::Capture::AppBroadcastPlugInManager^>(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::Media::Capture::AppBroadcastPlugInManager^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppBroadcastPlugInManager^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppBroadcastPlugInManager(winRtInstance));
    }





    static void GetDefault(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Media::Capture::AppBroadcastPlugInManager^ result;
          result = ::Windows::Media::Capture::AppBroadcastPlugInManager::GetDefault();
          info.GetReturnValue().Set(WrapAppBroadcastPlugInManager(result));
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }

    static void GetForUser(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::System::User^>(info[0]))
      {
        try
        {
          ::Windows::System::User^ arg0 = dynamic_cast<::Windows::System::User^>(NodeRT::Utils::GetObjectInstance(info[0]));
          
          ::Windows::Media::Capture::AppBroadcastPlugInManager^ result;
          result = ::Windows::Media::Capture::AppBroadcastPlugInManager::GetForUser(arg0);
          info.GetReturnValue().Set(WrapAppBroadcastPlugInManager(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 DefaultPlugInGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPlugInManager^>(info.This())) {
        return;
      }

      AppBroadcastPlugInManager *wrapper = AppBroadcastPlugInManager::Unwrap<AppBroadcastPlugInManager>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastPlugIn^ result = wrapper->_instance->DefaultPlugIn;
        info.GetReturnValue().Set(WrapAppBroadcastPlugIn(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DefaultPlugInSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPlugIn^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPlugInManager^>(info.This())) {
        return;
      }

      AppBroadcastPlugInManager *wrapper = AppBroadcastPlugInManager::Unwrap<AppBroadcastPlugInManager>(info.This());

      try {

        ::Windows::Media::Capture::AppBroadcastPlugIn^ winRtValue = dynamic_cast<::Windows::Media::Capture::AppBroadcastPlugIn^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->DefaultPlugIn = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsBroadcastProviderAvailableGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPlugInManager^>(info.This())) {
        return;
      }

      AppBroadcastPlugInManager *wrapper = AppBroadcastPlugInManager::Unwrap<AppBroadcastPlugInManager>(info.This());

      try  {
        bool result = wrapper->_instance->IsBroadcastProviderAvailable;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PlugInListGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPlugInManager^>(info.This())) {
        return;
      }

      AppBroadcastPlugInManager *wrapper = AppBroadcastPlugInManager::Unwrap<AppBroadcastPlugInManager>(info.This());

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Media::Capture::AppBroadcastPlugIn^>^ result = wrapper->_instance->PlugInList;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Media::Capture::AppBroadcastPlugIn^>::CreateVectorViewWrapper(result, 
            [](::Windows::Media::Capture::AppBroadcastPlugIn^ val) -> Local<Value> {
              return WrapAppBroadcastPlugIn(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPlugIn^>(value);
            },
            [](Local<Value> value) -> ::Windows::Media::Capture::AppBroadcastPlugIn^ {
              return UnwrapAppBroadcastPlugIn(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::AppBroadcastPlugInManager^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppBroadcastPlugInManager(::Windows::Media::Capture::AppBroadcastPlugInManager^ wintRtInstance);
      friend ::Windows::Media::Capture::AppBroadcastPlugInManager^ UnwrapAppBroadcastPlugInManager(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppBroadcastPlugInManager::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppBroadcastPlugInManager(::Windows::Media::Capture::AppBroadcastPlugInManager^ 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>(AppBroadcastPlugInManager::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppBroadcastPlugInManager^ UnwrapAppBroadcastPlugInManager(Local<Value> value) {
     return AppBroadcastPlugInManager::Unwrap<AppBroadcastPlugInManager>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppBroadcastPlugInManager(Local<Object> exports) {
    AppBroadcastPlugInManager::Init(exports);
  }

  class AppBroadcastPlugIn : 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>("AppBroadcastPlugIn").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("appId").ToLocalChecked(), AppIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("displayName").ToLocalChecked(), DisplayNameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("logo").ToLocalChecked(), LogoGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("providerSettings").ToLocalChecked(), ProviderSettingsGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppBroadcastPlugIn").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppBroadcastPlugIn(::Windows::Media::Capture::AppBroadcastPlugIn^ 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::Media::Capture::AppBroadcastPlugIn^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPlugIn^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppBroadcastPlugIn^) 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());

      AppBroadcastPlugIn *wrapperInstance = new AppBroadcastPlugIn(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::Media::Capture::AppBroadcastPlugIn^>(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::Media::Capture::AppBroadcastPlugIn^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppBroadcastPlugIn^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppBroadcastPlugIn(winRtInstance));
    }





    static void AppIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPlugIn^>(info.This())) {
        return;
      }

      AppBroadcastPlugIn *wrapper = AppBroadcastPlugIn::Unwrap<AppBroadcastPlugIn>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->AppId;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DisplayNameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPlugIn^>(info.This())) {
        return;
      }

      AppBroadcastPlugIn *wrapper = AppBroadcastPlugIn::Unwrap<AppBroadcastPlugIn>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->DisplayName;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void LogoGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPlugIn^>(info.This())) {
        return;
      }

      AppBroadcastPlugIn *wrapper = AppBroadcastPlugIn::Unwrap<AppBroadcastPlugIn>(info.This());

      try  {
        ::Windows::Storage::Streams::IRandomAccessStreamReference^ result = wrapper->_instance->Logo;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Storage.Streams", "IRandomAccessStreamReference", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ProviderSettingsGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPlugIn^>(info.This())) {
        return;
      }

      AppBroadcastPlugIn *wrapper = AppBroadcastPlugIn::Unwrap<AppBroadcastPlugIn>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastProviderSettings^ result = wrapper->_instance->ProviderSettings;
        info.GetReturnValue().Set(WrapAppBroadcastProviderSettings(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::AppBroadcastPlugIn^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppBroadcastPlugIn(::Windows::Media::Capture::AppBroadcastPlugIn^ wintRtInstance);
      friend ::Windows::Media::Capture::AppBroadcastPlugIn^ UnwrapAppBroadcastPlugIn(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppBroadcastPlugIn::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppBroadcastPlugIn(::Windows::Media::Capture::AppBroadcastPlugIn^ 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>(AppBroadcastPlugIn::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppBroadcastPlugIn^ UnwrapAppBroadcastPlugIn(Local<Value> value) {
     return AppBroadcastPlugIn::Unwrap<AppBroadcastPlugIn>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppBroadcastPlugIn(Local<Object> exports) {
    AppBroadcastPlugIn::Init(exports);
  }

  class AppBroadcastPreview : 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>("AppBroadcastPreview").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "stopPreview", StopPreview);
          


          
          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>("errorCode").ToLocalChecked(), ErrorCodeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("previewState").ToLocalChecked(), PreviewStateGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("previewStreamReader").ToLocalChecked(), PreviewStreamReaderGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppBroadcastPreview").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppBroadcastPreview(::Windows::Media::Capture::AppBroadcastPreview^ 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::Media::Capture::AppBroadcastPreview^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPreview^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppBroadcastPreview^) 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());

      AppBroadcastPreview *wrapperInstance = new AppBroadcastPreview(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::Media::Capture::AppBroadcastPreview^>(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::Media::Capture::AppBroadcastPreview^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppBroadcastPreview^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppBroadcastPreview(winRtInstance));
    }


    static void StopPreview(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPreview^>(info.This())) {
        return;
      }

      AppBroadcastPreview *wrapper = AppBroadcastPreview::Unwrap<AppBroadcastPreview>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->StopPreview();
          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 ErrorCodeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPreview^>(info.This())) {
        return;
      }

      AppBroadcastPreview *wrapper = AppBroadcastPreview::Unwrap<AppBroadcastPreview>(info.This());

      try  {
        ::Platform::IBox<unsigned int>^ result = wrapper->_instance->ErrorCode;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PreviewStateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPreview^>(info.This())) {
        return;
      }

      AppBroadcastPreview *wrapper = AppBroadcastPreview::Unwrap<AppBroadcastPreview>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastPreviewState result = wrapper->_instance->PreviewState;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PreviewStreamReaderGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPreview^>(info.This())) {
        return;
      }

      AppBroadcastPreview *wrapper = AppBroadcastPreview::Unwrap<AppBroadcastPreview>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastPreviewStreamReader^ result = wrapper->_instance->PreviewStreamReader;
        info.GetReturnValue().Set(WrapAppBroadcastPreviewStreamReader(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    static void AddListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"previewStateChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPreview^>(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;
        }
        AppBroadcastPreview *wrapper = AppBroadcastPreview::Unwrap<AppBroadcastPreview>(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->PreviewStateChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::AppBroadcastPreview^, ::Windows::Media::Capture::AppBroadcastPreviewStateChangedEventArgs^>(
            [callbackObjPtr](::Windows::Media::Capture::AppBroadcastPreview^ arg0, ::Windows::Media::Capture::AppBroadcastPreviewStateChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAppBroadcastPreview(arg0);
                  wrappedArg1 = WrapAppBroadcastPreviewStateChangedEventArgs(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"previewStateChanged", 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"previewStateChanged", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPreview^>(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;
          }
          AppBroadcastPreview *wrapper = AppBroadcastPreview::Unwrap<AppBroadcastPreview>(info.This());
          wrapper->_instance->PreviewStateChanged::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::Media::Capture::AppBroadcastPreview^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppBroadcastPreview(::Windows::Media::Capture::AppBroadcastPreview^ wintRtInstance);
      friend ::Windows::Media::Capture::AppBroadcastPreview^ UnwrapAppBroadcastPreview(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppBroadcastPreview::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppBroadcastPreview(::Windows::Media::Capture::AppBroadcastPreview^ 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>(AppBroadcastPreview::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppBroadcastPreview^ UnwrapAppBroadcastPreview(Local<Value> value) {
     return AppBroadcastPreview::Unwrap<AppBroadcastPreview>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppBroadcastPreview(Local<Object> exports) {
    AppBroadcastPreview::Init(exports);
  }

  class AppBroadcastState : 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>("AppBroadcastState").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "restartMicrophoneCapture", RestartMicrophoneCapture);
            Nan::SetPrototypeMethod(localRef, "restartCameraCapture", RestartCameraCapture);
          


          
          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>("signInState").ToLocalChecked(), SignInStateGetter, SignInStateSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("shouldCaptureMicrophone").ToLocalChecked(), ShouldCaptureMicrophoneGetter, ShouldCaptureMicrophoneSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("shouldCaptureCamera").ToLocalChecked(), ShouldCaptureCameraGetter, ShouldCaptureCameraSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("authenticationResult").ToLocalChecked(), AuthenticationResultGetter, AuthenticationResultSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isCaptureTargetRunning").ToLocalChecked(), IsCaptureTargetRunningGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("microphoneCaptureError").ToLocalChecked(), MicrophoneCaptureErrorGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("microphoneCaptureState").ToLocalChecked(), MicrophoneCaptureStateGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("oAuthCallbackUri").ToLocalChecked(), OAuthCallbackUriGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("oAuthRequestUri").ToLocalChecked(), OAuthRequestUriGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("plugInState").ToLocalChecked(), PlugInStateGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("cameraCaptureError").ToLocalChecked(), CameraCaptureErrorGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("cameraCaptureState").ToLocalChecked(), CameraCaptureStateGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("encodedVideoSize").ToLocalChecked(), EncodedVideoSizeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("streamState").ToLocalChecked(), StreamStateGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("terminationReason").ToLocalChecked(), TerminationReasonGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("terminationReasonPlugInSpecific").ToLocalChecked(), TerminationReasonPlugInSpecificGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("viewerCount").ToLocalChecked(), ViewerCountGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppBroadcastState").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppBroadcastState(::Windows::Media::Capture::AppBroadcastState^ 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::Media::Capture::AppBroadcastState^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppBroadcastState^) 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());

      AppBroadcastState *wrapperInstance = new AppBroadcastState(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::Media::Capture::AppBroadcastState^>(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::Media::Capture::AppBroadcastState^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppBroadcastState^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppBroadcastState(winRtInstance));
    }


    static void RestartMicrophoneCapture(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(info.This())) {
        return;
      }

      AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->RestartMicrophoneCapture();
          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 RestartCameraCapture(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(info.This())) {
        return;
      }

      AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->RestartCameraCapture();
          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 SignInStateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(info.This())) {
        return;
      }

      AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastSignInState result = wrapper->_instance->SignInState;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SignInStateSetter(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::Media::Capture::AppBroadcastState^>(info.This())) {
        return;
      }

      AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());

      try {

        ::Windows::Media::Capture::AppBroadcastSignInState winRtValue = static_cast<::Windows::Media::Capture::AppBroadcastSignInState>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->SignInState = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ShouldCaptureMicrophoneGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(info.This())) {
        return;
      }

      AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());

      try  {
        bool result = wrapper->_instance->ShouldCaptureMicrophone;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ShouldCaptureMicrophoneSetter(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::Media::Capture::AppBroadcastState^>(info.This())) {
        return;
      }

      AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->ShouldCaptureMicrophone = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ShouldCaptureCameraGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(info.This())) {
        return;
      }

      AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());

      try  {
        bool result = wrapper->_instance->ShouldCaptureCamera;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ShouldCaptureCameraSetter(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::Media::Capture::AppBroadcastState^>(info.This())) {
        return;
      }

      AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->ShouldCaptureCamera = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void AuthenticationResultGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(info.This())) {
        return;
      }

      AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());

      try  {
        ::Windows::Security::Authentication::Web::WebAuthenticationResult^ result = wrapper->_instance->AuthenticationResult;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Security.Authentication.Web", "WebAuthenticationResult", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AuthenticationResultSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Security::Authentication::Web::WebAuthenticationResult^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(info.This())) {
        return;
      }

      AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());

      try {

        ::Windows::Security::Authentication::Web::WebAuthenticationResult^ winRtValue = dynamic_cast<::Windows::Security::Authentication::Web::WebAuthenticationResult^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->AuthenticationResult = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsCaptureTargetRunningGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(info.This())) {
        return;
      }

      AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());

      try  {
        bool result = wrapper->_instance->IsCaptureTargetRunning;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MicrophoneCaptureErrorGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(info.This())) {
        return;
      }

      AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());

      try  {
        unsigned int result = wrapper->_instance->MicrophoneCaptureError;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MicrophoneCaptureStateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(info.This())) {
        return;
      }

      AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastMicrophoneCaptureState result = wrapper->_instance->MicrophoneCaptureState;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void OAuthCallbackUriGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(info.This())) {
        return;
      }

      AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());

      try  {
        ::Windows::Foundation::Uri^ result = wrapper->_instance->OAuthCallbackUri;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "Uri", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void OAuthRequestUriGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(info.This())) {
        return;
      }

      AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());

      try  {
        ::Windows::Foundation::Uri^ result = wrapper->_instance->OAuthRequestUri;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Foundation", "Uri", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PlugInStateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(info.This())) {
        return;
      }

      AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastPlugInState result = wrapper->_instance->PlugInState;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CameraCaptureErrorGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(info.This())) {
        return;
      }

      AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());

      try  {
        unsigned int result = wrapper->_instance->CameraCaptureError;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CameraCaptureStateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(info.This())) {
        return;
      }

      AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastCameraCaptureState result = wrapper->_instance->CameraCaptureState;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void EncodedVideoSizeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(info.This())) {
        return;
      }

      AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());

      try  {
        ::Windows::Foundation::Size result = wrapper->_instance->EncodedVideoSize;
        info.GetReturnValue().Set(NodeRT::Utils::SizeToJs(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void StreamStateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(info.This())) {
        return;
      }

      AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastStreamState result = wrapper->_instance->StreamState;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TerminationReasonGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(info.This())) {
        return;
      }

      AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastTerminationReason result = wrapper->_instance->TerminationReason;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TerminationReasonPlugInSpecificGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(info.This())) {
        return;
      }

      AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());

      try  {
        unsigned int result = wrapper->_instance->TerminationReasonPlugInSpecific;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ViewerCountGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(info.This())) {
        return;
      }

      AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());

      try  {
        unsigned int result = wrapper->_instance->ViewerCount;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    static void AddListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"cameraCaptureStateChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(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;
        }
        AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(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->CameraCaptureStateChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::AppBroadcastState^, ::Windows::Media::Capture::AppBroadcastCameraCaptureStateChangedEventArgs^>(
            [callbackObjPtr](::Windows::Media::Capture::AppBroadcastState^ arg0, ::Windows::Media::Capture::AppBroadcastCameraCaptureStateChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAppBroadcastState(arg0);
                  wrappedArg1 = WrapAppBroadcastCameraCaptureStateChangedEventArgs(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"captureTargetClosed", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(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;
        }
        AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(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->CaptureTargetClosed::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::AppBroadcastState^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Media::Capture::AppBroadcastState^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAppBroadcastState(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"microphoneCaptureStateChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(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;
        }
        AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(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->MicrophoneCaptureStateChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::AppBroadcastState^, ::Windows::Media::Capture::AppBroadcastMicrophoneCaptureStateChangedEventArgs^>(
            [callbackObjPtr](::Windows::Media::Capture::AppBroadcastState^ arg0, ::Windows::Media::Capture::AppBroadcastMicrophoneCaptureStateChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAppBroadcastState(arg0);
                  wrappedArg1 = WrapAppBroadcastMicrophoneCaptureStateChangedEventArgs(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"plugInStateChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(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;
        }
        AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(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->PlugInStateChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::AppBroadcastState^, ::Windows::Media::Capture::AppBroadcastPlugInStateChangedEventArgs^>(
            [callbackObjPtr](::Windows::Media::Capture::AppBroadcastState^ arg0, ::Windows::Media::Capture::AppBroadcastPlugInStateChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAppBroadcastState(arg0);
                  wrappedArg1 = WrapAppBroadcastPlugInStateChangedEventArgs(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"streamStateChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(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;
        }
        AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(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->StreamStateChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::AppBroadcastState^, ::Windows::Media::Capture::AppBroadcastStreamStateChangedEventArgs^>(
            [callbackObjPtr](::Windows::Media::Capture::AppBroadcastState^ arg0, ::Windows::Media::Capture::AppBroadcastStreamStateChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAppBroadcastState(arg0);
                  wrappedArg1 = WrapAppBroadcastStreamStateChangedEventArgs(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"viewerCountChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(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;
        }
        AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(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->ViewerCountChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::AppBroadcastState^, ::Windows::Media::Capture::AppBroadcastViewerCountChangedEventArgs^>(
            [callbackObjPtr](::Windows::Media::Capture::AppBroadcastState^ arg0, ::Windows::Media::Capture::AppBroadcastViewerCountChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAppBroadcastState(arg0);
                  wrappedArg1 = WrapAppBroadcastViewerCountChangedEventArgs(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"cameraCaptureStateChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"captureTargetClosed", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"microphoneCaptureStateChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"plugInStateChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"streamStateChanged", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"viewerCountChanged", 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"cameraCaptureStateChanged", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(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;
          }
          AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());
          wrapper->_instance->CameraCaptureStateChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"captureTargetClosed", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(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;
          }
          AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());
          wrapper->_instance->CaptureTargetClosed::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"microphoneCaptureStateChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(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;
          }
          AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());
          wrapper->_instance->MicrophoneCaptureStateChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"plugInStateChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(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;
          }
          AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());
          wrapper->_instance->PlugInStateChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"streamStateChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(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;
          }
          AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());
          wrapper->_instance->StreamStateChanged::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"viewerCountChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastState^>(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;
          }
          AppBroadcastState *wrapper = AppBroadcastState::Unwrap<AppBroadcastState>(info.This());
          wrapper->_instance->ViewerCountChanged::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::Media::Capture::AppBroadcastState^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppBroadcastState(::Windows::Media::Capture::AppBroadcastState^ wintRtInstance);
      friend ::Windows::Media::Capture::AppBroadcastState^ UnwrapAppBroadcastState(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppBroadcastState::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppBroadcastState(::Windows::Media::Capture::AppBroadcastState^ 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>(AppBroadcastState::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppBroadcastState^ UnwrapAppBroadcastState(Local<Value> value) {
     return AppBroadcastState::Unwrap<AppBroadcastState>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppBroadcastState(Local<Object> exports) {
    AppBroadcastState::Init(exports);
  }

  class AppBroadcastViewerCountChangedEventArgs : 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>("AppBroadcastViewerCountChangedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("viewerCount").ToLocalChecked(), ViewerCountGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppBroadcastViewerCountChangedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppBroadcastViewerCountChangedEventArgs(::Windows::Media::Capture::AppBroadcastViewerCountChangedEventArgs^ 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::Media::Capture::AppBroadcastViewerCountChangedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastViewerCountChangedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppBroadcastViewerCountChangedEventArgs^) 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());

      AppBroadcastViewerCountChangedEventArgs *wrapperInstance = new AppBroadcastViewerCountChangedEventArgs(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::Media::Capture::AppBroadcastViewerCountChangedEventArgs^>(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::Media::Capture::AppBroadcastViewerCountChangedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppBroadcastViewerCountChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppBroadcastViewerCountChangedEventArgs(winRtInstance));
    }





    static void ViewerCountGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastViewerCountChangedEventArgs^>(info.This())) {
        return;
      }

      AppBroadcastViewerCountChangedEventArgs *wrapper = AppBroadcastViewerCountChangedEventArgs::Unwrap<AppBroadcastViewerCountChangedEventArgs>(info.This());

      try  {
        unsigned int result = wrapper->_instance->ViewerCount;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::AppBroadcastViewerCountChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppBroadcastViewerCountChangedEventArgs(::Windows::Media::Capture::AppBroadcastViewerCountChangedEventArgs^ wintRtInstance);
      friend ::Windows::Media::Capture::AppBroadcastViewerCountChangedEventArgs^ UnwrapAppBroadcastViewerCountChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppBroadcastViewerCountChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppBroadcastViewerCountChangedEventArgs(::Windows::Media::Capture::AppBroadcastViewerCountChangedEventArgs^ 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>(AppBroadcastViewerCountChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppBroadcastViewerCountChangedEventArgs^ UnwrapAppBroadcastViewerCountChangedEventArgs(Local<Value> value) {
     return AppBroadcastViewerCountChangedEventArgs::Unwrap<AppBroadcastViewerCountChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppBroadcastViewerCountChangedEventArgs(Local<Object> exports) {
    AppBroadcastViewerCountChangedEventArgs::Init(exports);
  }

  class AppBroadcastMicrophoneCaptureStateChangedEventArgs : 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>("AppBroadcastMicrophoneCaptureStateChangedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("errorCode").ToLocalChecked(), ErrorCodeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("state").ToLocalChecked(), StateGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppBroadcastMicrophoneCaptureStateChangedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppBroadcastMicrophoneCaptureStateChangedEventArgs(::Windows::Media::Capture::AppBroadcastMicrophoneCaptureStateChangedEventArgs^ 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::Media::Capture::AppBroadcastMicrophoneCaptureStateChangedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastMicrophoneCaptureStateChangedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppBroadcastMicrophoneCaptureStateChangedEventArgs^) 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());

      AppBroadcastMicrophoneCaptureStateChangedEventArgs *wrapperInstance = new AppBroadcastMicrophoneCaptureStateChangedEventArgs(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::Media::Capture::AppBroadcastMicrophoneCaptureStateChangedEventArgs^>(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::Media::Capture::AppBroadcastMicrophoneCaptureStateChangedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppBroadcastMicrophoneCaptureStateChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppBroadcastMicrophoneCaptureStateChangedEventArgs(winRtInstance));
    }





    static void ErrorCodeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastMicrophoneCaptureStateChangedEventArgs^>(info.This())) {
        return;
      }

      AppBroadcastMicrophoneCaptureStateChangedEventArgs *wrapper = AppBroadcastMicrophoneCaptureStateChangedEventArgs::Unwrap<AppBroadcastMicrophoneCaptureStateChangedEventArgs>(info.This());

      try  {
        unsigned int result = wrapper->_instance->ErrorCode;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void StateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastMicrophoneCaptureStateChangedEventArgs^>(info.This())) {
        return;
      }

      AppBroadcastMicrophoneCaptureStateChangedEventArgs *wrapper = AppBroadcastMicrophoneCaptureStateChangedEventArgs::Unwrap<AppBroadcastMicrophoneCaptureStateChangedEventArgs>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastMicrophoneCaptureState result = wrapper->_instance->State;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::AppBroadcastMicrophoneCaptureStateChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppBroadcastMicrophoneCaptureStateChangedEventArgs(::Windows::Media::Capture::AppBroadcastMicrophoneCaptureStateChangedEventArgs^ wintRtInstance);
      friend ::Windows::Media::Capture::AppBroadcastMicrophoneCaptureStateChangedEventArgs^ UnwrapAppBroadcastMicrophoneCaptureStateChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppBroadcastMicrophoneCaptureStateChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppBroadcastMicrophoneCaptureStateChangedEventArgs(::Windows::Media::Capture::AppBroadcastMicrophoneCaptureStateChangedEventArgs^ 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>(AppBroadcastMicrophoneCaptureStateChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppBroadcastMicrophoneCaptureStateChangedEventArgs^ UnwrapAppBroadcastMicrophoneCaptureStateChangedEventArgs(Local<Value> value) {
     return AppBroadcastMicrophoneCaptureStateChangedEventArgs::Unwrap<AppBroadcastMicrophoneCaptureStateChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppBroadcastMicrophoneCaptureStateChangedEventArgs(Local<Object> exports) {
    AppBroadcastMicrophoneCaptureStateChangedEventArgs::Init(exports);
  }

  class AppBroadcastCameraCaptureStateChangedEventArgs : 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>("AppBroadcastCameraCaptureStateChangedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("errorCode").ToLocalChecked(), ErrorCodeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("state").ToLocalChecked(), StateGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppBroadcastCameraCaptureStateChangedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppBroadcastCameraCaptureStateChangedEventArgs(::Windows::Media::Capture::AppBroadcastCameraCaptureStateChangedEventArgs^ 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::Media::Capture::AppBroadcastCameraCaptureStateChangedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastCameraCaptureStateChangedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppBroadcastCameraCaptureStateChangedEventArgs^) 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());

      AppBroadcastCameraCaptureStateChangedEventArgs *wrapperInstance = new AppBroadcastCameraCaptureStateChangedEventArgs(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::Media::Capture::AppBroadcastCameraCaptureStateChangedEventArgs^>(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::Media::Capture::AppBroadcastCameraCaptureStateChangedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppBroadcastCameraCaptureStateChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppBroadcastCameraCaptureStateChangedEventArgs(winRtInstance));
    }





    static void ErrorCodeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastCameraCaptureStateChangedEventArgs^>(info.This())) {
        return;
      }

      AppBroadcastCameraCaptureStateChangedEventArgs *wrapper = AppBroadcastCameraCaptureStateChangedEventArgs::Unwrap<AppBroadcastCameraCaptureStateChangedEventArgs>(info.This());

      try  {
        unsigned int result = wrapper->_instance->ErrorCode;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void StateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastCameraCaptureStateChangedEventArgs^>(info.This())) {
        return;
      }

      AppBroadcastCameraCaptureStateChangedEventArgs *wrapper = AppBroadcastCameraCaptureStateChangedEventArgs::Unwrap<AppBroadcastCameraCaptureStateChangedEventArgs>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastCameraCaptureState result = wrapper->_instance->State;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::AppBroadcastCameraCaptureStateChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppBroadcastCameraCaptureStateChangedEventArgs(::Windows::Media::Capture::AppBroadcastCameraCaptureStateChangedEventArgs^ wintRtInstance);
      friend ::Windows::Media::Capture::AppBroadcastCameraCaptureStateChangedEventArgs^ UnwrapAppBroadcastCameraCaptureStateChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppBroadcastCameraCaptureStateChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppBroadcastCameraCaptureStateChangedEventArgs(::Windows::Media::Capture::AppBroadcastCameraCaptureStateChangedEventArgs^ 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>(AppBroadcastCameraCaptureStateChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppBroadcastCameraCaptureStateChangedEventArgs^ UnwrapAppBroadcastCameraCaptureStateChangedEventArgs(Local<Value> value) {
     return AppBroadcastCameraCaptureStateChangedEventArgs::Unwrap<AppBroadcastCameraCaptureStateChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppBroadcastCameraCaptureStateChangedEventArgs(Local<Object> exports) {
    AppBroadcastCameraCaptureStateChangedEventArgs::Init(exports);
  }

  class AppBroadcastPlugInStateChangedEventArgs : 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>("AppBroadcastPlugInStateChangedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("plugInState").ToLocalChecked(), PlugInStateGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppBroadcastPlugInStateChangedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppBroadcastPlugInStateChangedEventArgs(::Windows::Media::Capture::AppBroadcastPlugInStateChangedEventArgs^ 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::Media::Capture::AppBroadcastPlugInStateChangedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPlugInStateChangedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppBroadcastPlugInStateChangedEventArgs^) 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());

      AppBroadcastPlugInStateChangedEventArgs *wrapperInstance = new AppBroadcastPlugInStateChangedEventArgs(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::Media::Capture::AppBroadcastPlugInStateChangedEventArgs^>(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::Media::Capture::AppBroadcastPlugInStateChangedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppBroadcastPlugInStateChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppBroadcastPlugInStateChangedEventArgs(winRtInstance));
    }





    static void PlugInStateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPlugInStateChangedEventArgs^>(info.This())) {
        return;
      }

      AppBroadcastPlugInStateChangedEventArgs *wrapper = AppBroadcastPlugInStateChangedEventArgs::Unwrap<AppBroadcastPlugInStateChangedEventArgs>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastPlugInState result = wrapper->_instance->PlugInState;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::AppBroadcastPlugInStateChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppBroadcastPlugInStateChangedEventArgs(::Windows::Media::Capture::AppBroadcastPlugInStateChangedEventArgs^ wintRtInstance);
      friend ::Windows::Media::Capture::AppBroadcastPlugInStateChangedEventArgs^ UnwrapAppBroadcastPlugInStateChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppBroadcastPlugInStateChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppBroadcastPlugInStateChangedEventArgs(::Windows::Media::Capture::AppBroadcastPlugInStateChangedEventArgs^ 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>(AppBroadcastPlugInStateChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppBroadcastPlugInStateChangedEventArgs^ UnwrapAppBroadcastPlugInStateChangedEventArgs(Local<Value> value) {
     return AppBroadcastPlugInStateChangedEventArgs::Unwrap<AppBroadcastPlugInStateChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppBroadcastPlugInStateChangedEventArgs(Local<Object> exports) {
    AppBroadcastPlugInStateChangedEventArgs::Init(exports);
  }

  class AppBroadcastPreviewStateChangedEventArgs : 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>("AppBroadcastPreviewStateChangedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("errorCode").ToLocalChecked(), ErrorCodeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("previewState").ToLocalChecked(), PreviewStateGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppBroadcastPreviewStateChangedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppBroadcastPreviewStateChangedEventArgs(::Windows::Media::Capture::AppBroadcastPreviewStateChangedEventArgs^ 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::Media::Capture::AppBroadcastPreviewStateChangedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPreviewStateChangedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppBroadcastPreviewStateChangedEventArgs^) 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());

      AppBroadcastPreviewStateChangedEventArgs *wrapperInstance = new AppBroadcastPreviewStateChangedEventArgs(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::Media::Capture::AppBroadcastPreviewStateChangedEventArgs^>(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::Media::Capture::AppBroadcastPreviewStateChangedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppBroadcastPreviewStateChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppBroadcastPreviewStateChangedEventArgs(winRtInstance));
    }





    static void ErrorCodeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPreviewStateChangedEventArgs^>(info.This())) {
        return;
      }

      AppBroadcastPreviewStateChangedEventArgs *wrapper = AppBroadcastPreviewStateChangedEventArgs::Unwrap<AppBroadcastPreviewStateChangedEventArgs>(info.This());

      try  {
        unsigned int result = wrapper->_instance->ErrorCode;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void PreviewStateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPreviewStateChangedEventArgs^>(info.This())) {
        return;
      }

      AppBroadcastPreviewStateChangedEventArgs *wrapper = AppBroadcastPreviewStateChangedEventArgs::Unwrap<AppBroadcastPreviewStateChangedEventArgs>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastPreviewState result = wrapper->_instance->PreviewState;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::AppBroadcastPreviewStateChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppBroadcastPreviewStateChangedEventArgs(::Windows::Media::Capture::AppBroadcastPreviewStateChangedEventArgs^ wintRtInstance);
      friend ::Windows::Media::Capture::AppBroadcastPreviewStateChangedEventArgs^ UnwrapAppBroadcastPreviewStateChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppBroadcastPreviewStateChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppBroadcastPreviewStateChangedEventArgs(::Windows::Media::Capture::AppBroadcastPreviewStateChangedEventArgs^ 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>(AppBroadcastPreviewStateChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppBroadcastPreviewStateChangedEventArgs^ UnwrapAppBroadcastPreviewStateChangedEventArgs(Local<Value> value) {
     return AppBroadcastPreviewStateChangedEventArgs::Unwrap<AppBroadcastPreviewStateChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppBroadcastPreviewStateChangedEventArgs(Local<Object> exports) {
    AppBroadcastPreviewStateChangedEventArgs::Init(exports);
  }

  class AppBroadcastPreviewStreamReader : 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>("AppBroadcastPreviewStreamReader").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "tryGetNextVideoFrame", TryGetNextVideoFrame);
          


          
          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>("videoBitmapAlphaMode").ToLocalChecked(), VideoBitmapAlphaModeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoBitmapPixelFormat").ToLocalChecked(), VideoBitmapPixelFormatGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoHeight").ToLocalChecked(), VideoHeightGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoStride").ToLocalChecked(), VideoStrideGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoWidth").ToLocalChecked(), VideoWidthGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppBroadcastPreviewStreamReader").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppBroadcastPreviewStreamReader(::Windows::Media::Capture::AppBroadcastPreviewStreamReader^ 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::Media::Capture::AppBroadcastPreviewStreamReader^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPreviewStreamReader^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppBroadcastPreviewStreamReader^) 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());

      AppBroadcastPreviewStreamReader *wrapperInstance = new AppBroadcastPreviewStreamReader(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::Media::Capture::AppBroadcastPreviewStreamReader^>(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::Media::Capture::AppBroadcastPreviewStreamReader^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppBroadcastPreviewStreamReader^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppBroadcastPreviewStreamReader(winRtInstance));
    }


    static void TryGetNextVideoFrame(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPreviewStreamReader^>(info.This())) {
        return;
      }

      AppBroadcastPreviewStreamReader *wrapper = AppBroadcastPreviewStreamReader::Unwrap<AppBroadcastPreviewStreamReader>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Media::Capture::AppBroadcastPreviewStreamVideoFrame^ result;
          result = wrapper->_instance->TryGetNextVideoFrame();
          info.GetReturnValue().Set(WrapAppBroadcastPreviewStreamVideoFrame(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 VideoBitmapAlphaModeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPreviewStreamReader^>(info.This())) {
        return;
      }

      AppBroadcastPreviewStreamReader *wrapper = AppBroadcastPreviewStreamReader::Unwrap<AppBroadcastPreviewStreamReader>(info.This());

      try  {
        ::Windows::Graphics::Imaging::BitmapAlphaMode result = wrapper->_instance->VideoBitmapAlphaMode;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VideoBitmapPixelFormatGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPreviewStreamReader^>(info.This())) {
        return;
      }

      AppBroadcastPreviewStreamReader *wrapper = AppBroadcastPreviewStreamReader::Unwrap<AppBroadcastPreviewStreamReader>(info.This());

      try  {
        ::Windows::Graphics::Imaging::BitmapPixelFormat result = wrapper->_instance->VideoBitmapPixelFormat;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VideoHeightGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPreviewStreamReader^>(info.This())) {
        return;
      }

      AppBroadcastPreviewStreamReader *wrapper = AppBroadcastPreviewStreamReader::Unwrap<AppBroadcastPreviewStreamReader>(info.This());

      try  {
        unsigned int result = wrapper->_instance->VideoHeight;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VideoStrideGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPreviewStreamReader^>(info.This())) {
        return;
      }

      AppBroadcastPreviewStreamReader *wrapper = AppBroadcastPreviewStreamReader::Unwrap<AppBroadcastPreviewStreamReader>(info.This());

      try  {
        unsigned int result = wrapper->_instance->VideoStride;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VideoWidthGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPreviewStreamReader^>(info.This())) {
        return;
      }

      AppBroadcastPreviewStreamReader *wrapper = AppBroadcastPreviewStreamReader::Unwrap<AppBroadcastPreviewStreamReader>(info.This());

      try  {
        unsigned int result = wrapper->_instance->VideoWidth;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    static void AddListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"videoFrameArrived", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPreviewStreamReader^>(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;
        }
        AppBroadcastPreviewStreamReader *wrapper = AppBroadcastPreviewStreamReader::Unwrap<AppBroadcastPreviewStreamReader>(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->VideoFrameArrived::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::AppBroadcastPreviewStreamReader^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Media::Capture::AppBroadcastPreviewStreamReader^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAppBroadcastPreviewStreamReader(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"videoFrameArrived", 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"videoFrameArrived", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPreviewStreamReader^>(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;
          }
          AppBroadcastPreviewStreamReader *wrapper = AppBroadcastPreviewStreamReader::Unwrap<AppBroadcastPreviewStreamReader>(info.This());
          wrapper->_instance->VideoFrameArrived::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::Media::Capture::AppBroadcastPreviewStreamReader^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppBroadcastPreviewStreamReader(::Windows::Media::Capture::AppBroadcastPreviewStreamReader^ wintRtInstance);
      friend ::Windows::Media::Capture::AppBroadcastPreviewStreamReader^ UnwrapAppBroadcastPreviewStreamReader(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppBroadcastPreviewStreamReader::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppBroadcastPreviewStreamReader(::Windows::Media::Capture::AppBroadcastPreviewStreamReader^ 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>(AppBroadcastPreviewStreamReader::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppBroadcastPreviewStreamReader^ UnwrapAppBroadcastPreviewStreamReader(Local<Value> value) {
     return AppBroadcastPreviewStreamReader::Unwrap<AppBroadcastPreviewStreamReader>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppBroadcastPreviewStreamReader(Local<Object> exports) {
    AppBroadcastPreviewStreamReader::Init(exports);
  }

  class AppBroadcastPreviewStreamVideoFrame : 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>("AppBroadcastPreviewStreamVideoFrame").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoBuffer").ToLocalChecked(), VideoBufferGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoHeader").ToLocalChecked(), VideoHeaderGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppBroadcastPreviewStreamVideoFrame").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppBroadcastPreviewStreamVideoFrame(::Windows::Media::Capture::AppBroadcastPreviewStreamVideoFrame^ 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::Media::Capture::AppBroadcastPreviewStreamVideoFrame^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPreviewStreamVideoFrame^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppBroadcastPreviewStreamVideoFrame^) 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());

      AppBroadcastPreviewStreamVideoFrame *wrapperInstance = new AppBroadcastPreviewStreamVideoFrame(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::Media::Capture::AppBroadcastPreviewStreamVideoFrame^>(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::Media::Capture::AppBroadcastPreviewStreamVideoFrame^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppBroadcastPreviewStreamVideoFrame^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppBroadcastPreviewStreamVideoFrame(winRtInstance));
    }





    static void VideoBufferGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPreviewStreamVideoFrame^>(info.This())) {
        return;
      }

      AppBroadcastPreviewStreamVideoFrame *wrapper = AppBroadcastPreviewStreamVideoFrame::Unwrap<AppBroadcastPreviewStreamVideoFrame>(info.This());

      try  {
        ::Windows::Storage::Streams::IBuffer^ result = wrapper->_instance->VideoBuffer;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Storage.Streams", "IBuffer", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VideoHeaderGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPreviewStreamVideoFrame^>(info.This())) {
        return;
      }

      AppBroadcastPreviewStreamVideoFrame *wrapper = AppBroadcastPreviewStreamVideoFrame::Unwrap<AppBroadcastPreviewStreamVideoFrame>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastPreviewStreamVideoHeader^ result = wrapper->_instance->VideoHeader;
        info.GetReturnValue().Set(WrapAppBroadcastPreviewStreamVideoHeader(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::AppBroadcastPreviewStreamVideoFrame^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppBroadcastPreviewStreamVideoFrame(::Windows::Media::Capture::AppBroadcastPreviewStreamVideoFrame^ wintRtInstance);
      friend ::Windows::Media::Capture::AppBroadcastPreviewStreamVideoFrame^ UnwrapAppBroadcastPreviewStreamVideoFrame(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppBroadcastPreviewStreamVideoFrame::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppBroadcastPreviewStreamVideoFrame(::Windows::Media::Capture::AppBroadcastPreviewStreamVideoFrame^ 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>(AppBroadcastPreviewStreamVideoFrame::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppBroadcastPreviewStreamVideoFrame^ UnwrapAppBroadcastPreviewStreamVideoFrame(Local<Value> value) {
     return AppBroadcastPreviewStreamVideoFrame::Unwrap<AppBroadcastPreviewStreamVideoFrame>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppBroadcastPreviewStreamVideoFrame(Local<Object> exports) {
    AppBroadcastPreviewStreamVideoFrame::Init(exports);
  }

  class AppBroadcastPreviewStreamVideoHeader : 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>("AppBroadcastPreviewStreamVideoHeader").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("absoluteTimestamp").ToLocalChecked(), AbsoluteTimestampGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("duration").ToLocalChecked(), DurationGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("frameId").ToLocalChecked(), FrameIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("relativeTimestamp").ToLocalChecked(), RelativeTimestampGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppBroadcastPreviewStreamVideoHeader").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppBroadcastPreviewStreamVideoHeader(::Windows::Media::Capture::AppBroadcastPreviewStreamVideoHeader^ 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::Media::Capture::AppBroadcastPreviewStreamVideoHeader^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPreviewStreamVideoHeader^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppBroadcastPreviewStreamVideoHeader^) 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());

      AppBroadcastPreviewStreamVideoHeader *wrapperInstance = new AppBroadcastPreviewStreamVideoHeader(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::Media::Capture::AppBroadcastPreviewStreamVideoHeader^>(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::Media::Capture::AppBroadcastPreviewStreamVideoHeader^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppBroadcastPreviewStreamVideoHeader^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppBroadcastPreviewStreamVideoHeader(winRtInstance));
    }





    static void AbsoluteTimestampGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPreviewStreamVideoHeader^>(info.This())) {
        return;
      }

      AppBroadcastPreviewStreamVideoHeader *wrapper = AppBroadcastPreviewStreamVideoHeader::Unwrap<AppBroadcastPreviewStreamVideoHeader>(info.This());

      try  {
        ::Windows::Foundation::DateTime result = wrapper->_instance->AbsoluteTimestamp;
        info.GetReturnValue().Set(NodeRT::Utils::DateTimeToJS(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DurationGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPreviewStreamVideoHeader^>(info.This())) {
        return;
      }

      AppBroadcastPreviewStreamVideoHeader *wrapper = AppBroadcastPreviewStreamVideoHeader::Unwrap<AppBroadcastPreviewStreamVideoHeader>(info.This());

      try  {
        ::Windows::Foundation::TimeSpan result = wrapper->_instance->Duration;
        info.GetReturnValue().Set(Nan::New<Number>(result.Duration/10000.0));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void FrameIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPreviewStreamVideoHeader^>(info.This())) {
        return;
      }

      AppBroadcastPreviewStreamVideoHeader *wrapper = AppBroadcastPreviewStreamVideoHeader::Unwrap<AppBroadcastPreviewStreamVideoHeader>(info.This());

      try  {
        unsigned __int64 result = wrapper->_instance->FrameId;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void RelativeTimestampGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPreviewStreamVideoHeader^>(info.This())) {
        return;
      }

      AppBroadcastPreviewStreamVideoHeader *wrapper = AppBroadcastPreviewStreamVideoHeader::Unwrap<AppBroadcastPreviewStreamVideoHeader>(info.This());

      try  {
        ::Windows::Foundation::TimeSpan result = wrapper->_instance->RelativeTimestamp;
        info.GetReturnValue().Set(Nan::New<Number>(result.Duration/10000.0));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::AppBroadcastPreviewStreamVideoHeader^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppBroadcastPreviewStreamVideoHeader(::Windows::Media::Capture::AppBroadcastPreviewStreamVideoHeader^ wintRtInstance);
      friend ::Windows::Media::Capture::AppBroadcastPreviewStreamVideoHeader^ UnwrapAppBroadcastPreviewStreamVideoHeader(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppBroadcastPreviewStreamVideoHeader::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppBroadcastPreviewStreamVideoHeader(::Windows::Media::Capture::AppBroadcastPreviewStreamVideoHeader^ 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>(AppBroadcastPreviewStreamVideoHeader::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppBroadcastPreviewStreamVideoHeader^ UnwrapAppBroadcastPreviewStreamVideoHeader(Local<Value> value) {
     return AppBroadcastPreviewStreamVideoHeader::Unwrap<AppBroadcastPreviewStreamVideoHeader>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppBroadcastPreviewStreamVideoHeader(Local<Object> exports) {
    AppBroadcastPreviewStreamVideoHeader::Init(exports);
  }

  class AppBroadcastServices : 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>("AppBroadcastServices").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);

        Local<Function> func;
        Local<FunctionTemplate> funcTemplate;

          
            Nan::SetPrototypeMethod(localRef, "exitBroadcastMode", ExitBroadcastMode);
            Nan::SetPrototypeMethod(localRef, "startBroadcast", StartBroadcast);
            Nan::SetPrototypeMethod(localRef, "pauseBroadcast", PauseBroadcast);
            Nan::SetPrototypeMethod(localRef, "resumeBroadcast", ResumeBroadcast);
            Nan::SetPrototypeMethod(localRef, "startPreview", StartPreview);
          

          
            Nan::SetPrototypeMethod(localRef, "enterBroadcastModeAsync", EnterBroadcastModeAsync);
          


          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("captureTargetType").ToLocalChecked(), CaptureTargetTypeGetter, CaptureTargetTypeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("broadcastTitle").ToLocalChecked(), BroadcastTitleGetter, BroadcastTitleSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("broadcastLanguage").ToLocalChecked(), BroadcastLanguageGetter, BroadcastLanguageSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("canCapture").ToLocalChecked(), CanCaptureGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("state").ToLocalChecked(), StateGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("userName").ToLocalChecked(), UserNameGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppBroadcastServices").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppBroadcastServices(::Windows::Media::Capture::AppBroadcastServices^ 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::Media::Capture::AppBroadcastServices^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastServices^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppBroadcastServices^) 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());

      AppBroadcastServices *wrapperInstance = new AppBroadcastServices(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::Media::Capture::AppBroadcastServices^>(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::Media::Capture::AppBroadcastServices^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppBroadcastServices^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppBroadcastServices(winRtInstance));
    }

    static void EnterBroadcastModeAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastServices^>(info.This())) {
        return;
      }

      if (info.Length() == 0 || !info[info.Length() -1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: No callback was given")));
        return;
      }

      AppBroadcastServices *wrapper = AppBroadcastServices::Unwrap<AppBroadcastServices>(info.This());

      ::Windows::Foundation::IAsyncOperation<unsigned int>^ op;


      if (info.Length() == 2
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastPlugIn^>(info[0]))
      {
        try
        {
          ::Windows::Media::Capture::AppBroadcastPlugIn^ arg0 = UnwrapAppBroadcastPlugIn(info[0]);
          
          op = wrapper->_instance->EnterBroadcastModeAsync(arg0);
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }

      auto opTask = create_task(op);
      uv_async_t* asyncToken = NodeUtils::Async::GetAsyncToken(info[info.Length() -1].As<Function>());

      opTask.then( [asyncToken] (task<unsigned int> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = Nan::New<Integer>(result);
              if (tryCatch.HasCaught())
              {
                error = Nan::To<Object>(tryCatch.Exception()).ToLocalChecked();
              }
              else
              {
                error = Undefined();
              }
              if (arg1.IsEmpty()) arg1 = Undefined();
            }
            Local<Value> args[] = {error, arg1};


            invokeCallback(_countof(args), args);
          });
        } catch (Platform::Exception^ exception) {
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [exception](NodeUtils::InvokeCallbackDelegate invokeCallback) {
            Local<Value> error = NodeRT::Utils::WinRtExceptionToJsError(exception);

            Local<Value> args[] = {error};
            invokeCallback(_countof(args), args);
          });
        }
      });
    }

    static void ExitBroadcastMode(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastServices^>(info.This())) {
        return;
      }

      AppBroadcastServices *wrapper = AppBroadcastServices::Unwrap<AppBroadcastServices>(info.This());

      if (info.Length() == 1
        && info[0]->IsInt32())
      {
        try
        {
          ::Windows::Media::Capture::AppBroadcastExitBroadcastModeReason arg0 = static_cast<::Windows::Media::Capture::AppBroadcastExitBroadcastModeReason>(Nan::To<int32_t>(info[0]).FromMaybe(0));
          
          wrapper->_instance->ExitBroadcastMode(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 StartBroadcast(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastServices^>(info.This())) {
        return;
      }

      AppBroadcastServices *wrapper = AppBroadcastServices::Unwrap<AppBroadcastServices>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->StartBroadcast();
          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 PauseBroadcast(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastServices^>(info.This())) {
        return;
      }

      AppBroadcastServices *wrapper = AppBroadcastServices::Unwrap<AppBroadcastServices>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->PauseBroadcast();
          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 ResumeBroadcast(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastServices^>(info.This())) {
        return;
      }

      AppBroadcastServices *wrapper = AppBroadcastServices::Unwrap<AppBroadcastServices>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->ResumeBroadcast();
          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 StartPreview(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastServices^>(info.This())) {
        return;
      }

      AppBroadcastServices *wrapper = AppBroadcastServices::Unwrap<AppBroadcastServices>(info.This());

      if (info.Length() == 1
        && NodeRT::Utils::IsSize(info[0]))
      {
        try
        {
          ::Windows::Foundation::Size arg0 = NodeRT::Utils::SizeFromJs(info[0]);
          
          ::Windows::Media::Capture::AppBroadcastPreview^ result;
          result = wrapper->_instance->StartPreview(arg0);
          info.GetReturnValue().Set(WrapAppBroadcastPreview(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 CaptureTargetTypeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastServices^>(info.This())) {
        return;
      }

      AppBroadcastServices *wrapper = AppBroadcastServices::Unwrap<AppBroadcastServices>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastCaptureTargetType result = wrapper->_instance->CaptureTargetType;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CaptureTargetTypeSetter(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::Media::Capture::AppBroadcastServices^>(info.This())) {
        return;
      }

      AppBroadcastServices *wrapper = AppBroadcastServices::Unwrap<AppBroadcastServices>(info.This());

      try {

        ::Windows::Media::Capture::AppBroadcastCaptureTargetType winRtValue = static_cast<::Windows::Media::Capture::AppBroadcastCaptureTargetType>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->CaptureTargetType = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void BroadcastTitleGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastServices^>(info.This())) {
        return;
      }

      AppBroadcastServices *wrapper = AppBroadcastServices::Unwrap<AppBroadcastServices>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->BroadcastTitle;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BroadcastTitleSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsString()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastServices^>(info.This())) {
        return;
      }

      AppBroadcastServices *wrapper = AppBroadcastServices::Unwrap<AppBroadcastServices>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->BroadcastTitle = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void BroadcastLanguageGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastServices^>(info.This())) {
        return;
      }

      AppBroadcastServices *wrapper = AppBroadcastServices::Unwrap<AppBroadcastServices>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->BroadcastLanguage;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void BroadcastLanguageSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsString()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastServices^>(info.This())) {
        return;
      }

      AppBroadcastServices *wrapper = AppBroadcastServices::Unwrap<AppBroadcastServices>(info.This());

      try {

        Platform::String^ winRtValue = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));

        wrapper->_instance->BroadcastLanguage = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void CanCaptureGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastServices^>(info.This())) {
        return;
      }

      AppBroadcastServices *wrapper = AppBroadcastServices::Unwrap<AppBroadcastServices>(info.This());

      try  {
        bool result = wrapper->_instance->CanCapture;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void StateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastServices^>(info.This())) {
        return;
      }

      AppBroadcastServices *wrapper = AppBroadcastServices::Unwrap<AppBroadcastServices>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastState^ result = wrapper->_instance->State;
        info.GetReturnValue().Set(WrapAppBroadcastState(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void UserNameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppBroadcastServices^>(info.This())) {
        return;
      }

      AppBroadcastServices *wrapper = AppBroadcastServices::Unwrap<AppBroadcastServices>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->UserName;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::AppBroadcastServices^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppBroadcastServices(::Windows::Media::Capture::AppBroadcastServices^ wintRtInstance);
      friend ::Windows::Media::Capture::AppBroadcastServices^ UnwrapAppBroadcastServices(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppBroadcastServices::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppBroadcastServices(::Windows::Media::Capture::AppBroadcastServices^ 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>(AppBroadcastServices::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppBroadcastServices^ UnwrapAppBroadcastServices(Local<Value> value) {
     return AppBroadcastServices::Unwrap<AppBroadcastServices>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppBroadcastServices(Local<Object> exports) {
    AppBroadcastServices::Init(exports);
  }

  class AppCaptureSettings : 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>("AppCaptureSettings").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isHistoricalCaptureOnWirelessDisplayAllowed").ToLocalChecked(), IsHistoricalCaptureOnWirelessDisplayAllowedGetter, IsHistoricalCaptureOnWirelessDisplayAllowedSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoEncodingBitrateMode").ToLocalChecked(), VideoEncodingBitrateModeGetter, VideoEncodingBitrateModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isHistoricalCaptureOnBatteryAllowed").ToLocalChecked(), IsHistoricalCaptureOnBatteryAllowedGetter, IsHistoricalCaptureOnBatteryAllowedSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isAudioCaptureEnabled").ToLocalChecked(), IsAudioCaptureEnabledGetter, IsAudioCaptureEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isAppCaptureEnabled").ToLocalChecked(), IsAppCaptureEnabledGetter, IsAppCaptureEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("appCaptureDestinationFolder").ToLocalChecked(), AppCaptureDestinationFolderGetter, AppCaptureDestinationFolderSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("historicalBufferLength").ToLocalChecked(), HistoricalBufferLengthGetter, HistoricalBufferLengthSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isHistoricalCaptureEnabled").ToLocalChecked(), IsHistoricalCaptureEnabledGetter, IsHistoricalCaptureEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("customVideoEncodingWidth").ToLocalChecked(), CustomVideoEncodingWidthGetter, CustomVideoEncodingWidthSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("customVideoEncodingHeight").ToLocalChecked(), CustomVideoEncodingHeightGetter, CustomVideoEncodingHeightSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("customVideoEncodingBitrate").ToLocalChecked(), CustomVideoEncodingBitrateGetter, CustomVideoEncodingBitrateSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("audioEncodingBitrate").ToLocalChecked(), AudioEncodingBitrateGetter, AudioEncodingBitrateSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("historicalBufferLengthUnit").ToLocalChecked(), HistoricalBufferLengthUnitGetter, HistoricalBufferLengthUnitSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoEncodingResolutionMode").ToLocalChecked(), VideoEncodingResolutionModeGetter, VideoEncodingResolutionModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("screenshotDestinationFolder").ToLocalChecked(), ScreenshotDestinationFolderGetter, ScreenshotDestinationFolderSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("maximumRecordLength").ToLocalChecked(), MaximumRecordLengthGetter, MaximumRecordLengthSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("hasHardwareEncoder").ToLocalChecked(), HasHardwareEncoderGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isCpuConstrained").ToLocalChecked(), IsCpuConstrainedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isMemoryConstrained").ToLocalChecked(), IsMemoryConstrainedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isDisabledByPolicy").ToLocalChecked(), IsDisabledByPolicyGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("alternateShortcutKeys").ToLocalChecked(), AlternateShortcutKeysGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isGpuConstrained").ToLocalChecked(), IsGpuConstrainedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isMicrophoneCaptureEnabled").ToLocalChecked(), IsMicrophoneCaptureEnabledGetter, IsMicrophoneCaptureEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoEncodingFrameRateMode").ToLocalChecked(), VideoEncodingFrameRateModeGetter, VideoEncodingFrameRateModeSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("systemAudioGain").ToLocalChecked(), SystemAudioGainGetter, SystemAudioGainSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("microphoneGain").ToLocalChecked(), MicrophoneGainGetter, MicrophoneGainSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isMicrophoneCaptureEnabledByDefault").ToLocalChecked(), IsMicrophoneCaptureEnabledByDefaultGetter, IsMicrophoneCaptureEnabledByDefaultSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isEchoCancellationEnabled").ToLocalChecked(), IsEchoCancellationEnabledGetter, IsEchoCancellationEnabledSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isCursorImageCaptureEnabled").ToLocalChecked(), IsCursorImageCaptureEnabledGetter, IsCursorImageCaptureEnabledSetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppCaptureSettings").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppCaptureSettings(::Windows::Media::Capture::AppCaptureSettings^ 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::Media::Capture::AppCaptureSettings^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppCaptureSettings^) 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());

      AppCaptureSettings *wrapperInstance = new AppCaptureSettings(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::Media::Capture::AppCaptureSettings^>(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::Media::Capture::AppCaptureSettings^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppCaptureSettings^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppCaptureSettings(winRtInstance));
    }





    static void IsHistoricalCaptureOnWirelessDisplayAllowedGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        bool result = wrapper->_instance->IsHistoricalCaptureOnWirelessDisplayAllowed;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsHistoricalCaptureOnWirelessDisplayAllowedSetter(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::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsHistoricalCaptureOnWirelessDisplayAllowed = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void VideoEncodingBitrateModeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        ::Windows::Media::Capture::AppCaptureVideoEncodingBitrateMode result = wrapper->_instance->VideoEncodingBitrateMode;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VideoEncodingBitrateModeSetter(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::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try {

        ::Windows::Media::Capture::AppCaptureVideoEncodingBitrateMode winRtValue = static_cast<::Windows::Media::Capture::AppCaptureVideoEncodingBitrateMode>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->VideoEncodingBitrateMode = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsHistoricalCaptureOnBatteryAllowedGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        bool result = wrapper->_instance->IsHistoricalCaptureOnBatteryAllowed;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsHistoricalCaptureOnBatteryAllowedSetter(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::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsHistoricalCaptureOnBatteryAllowed = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsAudioCaptureEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        bool result = wrapper->_instance->IsAudioCaptureEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsAudioCaptureEnabledSetter(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::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsAudioCaptureEnabled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsAppCaptureEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        bool result = wrapper->_instance->IsAppCaptureEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsAppCaptureEnabledSetter(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::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsAppCaptureEnabled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void AppCaptureDestinationFolderGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        ::Windows::Storage::StorageFolder^ result = wrapper->_instance->AppCaptureDestinationFolder;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Storage", "StorageFolder", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AppCaptureDestinationFolderSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::StorageFolder^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try {

        ::Windows::Storage::StorageFolder^ winRtValue = dynamic_cast<::Windows::Storage::StorageFolder^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->AppCaptureDestinationFolder = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void HistoricalBufferLengthGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        unsigned int result = wrapper->_instance->HistoricalBufferLength;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void HistoricalBufferLengthSetter(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::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try {

        unsigned int winRtValue = static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));

        wrapper->_instance->HistoricalBufferLength = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsHistoricalCaptureEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        bool result = wrapper->_instance->IsHistoricalCaptureEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsHistoricalCaptureEnabledSetter(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::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsHistoricalCaptureEnabled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void CustomVideoEncodingWidthGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        unsigned int result = wrapper->_instance->CustomVideoEncodingWidth;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CustomVideoEncodingWidthSetter(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::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try {

        unsigned int winRtValue = static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));

        wrapper->_instance->CustomVideoEncodingWidth = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void CustomVideoEncodingHeightGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        unsigned int result = wrapper->_instance->CustomVideoEncodingHeight;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CustomVideoEncodingHeightSetter(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::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try {

        unsigned int winRtValue = static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));

        wrapper->_instance->CustomVideoEncodingHeight = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void CustomVideoEncodingBitrateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        unsigned int result = wrapper->_instance->CustomVideoEncodingBitrate;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void CustomVideoEncodingBitrateSetter(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::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try {

        unsigned int winRtValue = static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));

        wrapper->_instance->CustomVideoEncodingBitrate = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void AudioEncodingBitrateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        unsigned int result = wrapper->_instance->AudioEncodingBitrate;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AudioEncodingBitrateSetter(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::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try {

        unsigned int winRtValue = static_cast<unsigned int>(Nan::To<uint32_t>(value).FromMaybe(0));

        wrapper->_instance->AudioEncodingBitrate = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void HistoricalBufferLengthUnitGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        ::Windows::Media::Capture::AppCaptureHistoricalBufferLengthUnit result = wrapper->_instance->HistoricalBufferLengthUnit;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void HistoricalBufferLengthUnitSetter(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::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try {

        ::Windows::Media::Capture::AppCaptureHistoricalBufferLengthUnit winRtValue = static_cast<::Windows::Media::Capture::AppCaptureHistoricalBufferLengthUnit>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->HistoricalBufferLengthUnit = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void VideoEncodingResolutionModeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        ::Windows::Media::Capture::AppCaptureVideoEncodingResolutionMode result = wrapper->_instance->VideoEncodingResolutionMode;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VideoEncodingResolutionModeSetter(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::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try {

        ::Windows::Media::Capture::AppCaptureVideoEncodingResolutionMode winRtValue = static_cast<::Windows::Media::Capture::AppCaptureVideoEncodingResolutionMode>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->VideoEncodingResolutionMode = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ScreenshotDestinationFolderGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        ::Windows::Storage::StorageFolder^ result = wrapper->_instance->ScreenshotDestinationFolder;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Storage", "StorageFolder", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ScreenshotDestinationFolderSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::StorageFolder^>(value)) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try {

        ::Windows::Storage::StorageFolder^ winRtValue = dynamic_cast<::Windows::Storage::StorageFolder^>(NodeRT::Utils::GetObjectInstance(value));

        wrapper->_instance->ScreenshotDestinationFolder = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void MaximumRecordLengthGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        ::Windows::Foundation::TimeSpan result = wrapper->_instance->MaximumRecordLength;
        info.GetReturnValue().Set(Nan::New<Number>(result.Duration/10000.0));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MaximumRecordLengthSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try {

        ::Windows::Foundation::TimeSpan winRtValue = NodeRT::Utils::TimeSpanFromMilli(Nan::To<int64_t>(value).FromMaybe(0));

        wrapper->_instance->MaximumRecordLength = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void HasHardwareEncoderGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        bool result = wrapper->_instance->HasHardwareEncoder;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsCpuConstrainedGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        bool result = wrapper->_instance->IsCpuConstrained;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsMemoryConstrainedGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        bool result = wrapper->_instance->IsMemoryConstrained;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsDisabledByPolicyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        bool result = wrapper->_instance->IsDisabledByPolicy;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AlternateShortcutKeysGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        ::Windows::Media::Capture::AppCaptureAlternateShortcutKeys^ result = wrapper->_instance->AlternateShortcutKeys;
        info.GetReturnValue().Set(WrapAppCaptureAlternateShortcutKeys(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsGpuConstrainedGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        bool result = wrapper->_instance->IsGpuConstrained;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsMicrophoneCaptureEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        bool result = wrapper->_instance->IsMicrophoneCaptureEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsMicrophoneCaptureEnabledSetter(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::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsMicrophoneCaptureEnabled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void VideoEncodingFrameRateModeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        ::Windows::Media::Capture::AppCaptureVideoEncodingFrameRateMode result = wrapper->_instance->VideoEncodingFrameRateMode;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VideoEncodingFrameRateModeSetter(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::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try {

        ::Windows::Media::Capture::AppCaptureVideoEncodingFrameRateMode winRtValue = static_cast<::Windows::Media::Capture::AppCaptureVideoEncodingFrameRateMode>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->VideoEncodingFrameRateMode = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void SystemAudioGainGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        double result = wrapper->_instance->SystemAudioGain;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SystemAudioGainSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try {

        double winRtValue = Nan::To<double>(value).FromMaybe(0.0);

        wrapper->_instance->SystemAudioGain = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void MicrophoneGainGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        double result = wrapper->_instance->MicrophoneGain;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MicrophoneGainSetter(Local<String> property, Local<Value> value, const Nan::PropertyCallbackInfo<void> &info) {
      HandleScope scope;

      if (!value->IsNumber()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Value to set is of unexpected type")));
        return;
      }

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try {

        double winRtValue = Nan::To<double>(value).FromMaybe(0.0);

        wrapper->_instance->MicrophoneGain = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsMicrophoneCaptureEnabledByDefaultGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        bool result = wrapper->_instance->IsMicrophoneCaptureEnabledByDefault;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsMicrophoneCaptureEnabledByDefaultSetter(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::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsMicrophoneCaptureEnabledByDefault = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsEchoCancellationEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        bool result = wrapper->_instance->IsEchoCancellationEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsEchoCancellationEnabledSetter(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::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsEchoCancellationEnabled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsCursorImageCaptureEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try  {
        bool result = wrapper->_instance->IsCursorImageCaptureEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsCursorImageCaptureEnabledSetter(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::Media::Capture::AppCaptureSettings^>(info.This())) {
        return;
      }

      AppCaptureSettings *wrapper = AppCaptureSettings::Unwrap<AppCaptureSettings>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->IsCursorImageCaptureEnabled = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      


    private:
      ::Windows::Media::Capture::AppCaptureSettings^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppCaptureSettings(::Windows::Media::Capture::AppCaptureSettings^ wintRtInstance);
      friend ::Windows::Media::Capture::AppCaptureSettings^ UnwrapAppCaptureSettings(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppCaptureSettings::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppCaptureSettings(::Windows::Media::Capture::AppCaptureSettings^ 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>(AppCaptureSettings::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppCaptureSettings^ UnwrapAppCaptureSettings(Local<Value> value) {
     return AppCaptureSettings::Unwrap<AppCaptureSettings>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppCaptureSettings(Local<Object> exports) {
    AppCaptureSettings::Init(exports);
  }

  class AppCaptureAlternateShortcutKeys : 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>("AppCaptureAlternateShortcutKeys").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("toggleRecordingKeyModifiers").ToLocalChecked(), ToggleRecordingKeyModifiersGetter, ToggleRecordingKeyModifiersSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("toggleRecordingKey").ToLocalChecked(), ToggleRecordingKeyGetter, ToggleRecordingKeySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("toggleRecordingIndicatorKeyModifiers").ToLocalChecked(), ToggleRecordingIndicatorKeyModifiersGetter, ToggleRecordingIndicatorKeyModifiersSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("toggleRecordingIndicatorKey").ToLocalChecked(), ToggleRecordingIndicatorKeyGetter, ToggleRecordingIndicatorKeySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("toggleGameBarKeyModifiers").ToLocalChecked(), ToggleGameBarKeyModifiersGetter, ToggleGameBarKeyModifiersSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("toggleGameBarKey").ToLocalChecked(), ToggleGameBarKeyGetter, ToggleGameBarKeySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("takeScreenshotKeyModifiers").ToLocalChecked(), TakeScreenshotKeyModifiersGetter, TakeScreenshotKeyModifiersSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("takeScreenshotKey").ToLocalChecked(), TakeScreenshotKeyGetter, TakeScreenshotKeySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("saveHistoricalVideoKeyModifiers").ToLocalChecked(), SaveHistoricalVideoKeyModifiersGetter, SaveHistoricalVideoKeyModifiersSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("saveHistoricalVideoKey").ToLocalChecked(), SaveHistoricalVideoKeyGetter, SaveHistoricalVideoKeySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("toggleMicrophoneCaptureKeyModifiers").ToLocalChecked(), ToggleMicrophoneCaptureKeyModifiersGetter, ToggleMicrophoneCaptureKeyModifiersSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("toggleMicrophoneCaptureKey").ToLocalChecked(), ToggleMicrophoneCaptureKeyGetter, ToggleMicrophoneCaptureKeySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("toggleCameraCaptureKeyModifiers").ToLocalChecked(), ToggleCameraCaptureKeyModifiersGetter, ToggleCameraCaptureKeyModifiersSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("toggleCameraCaptureKey").ToLocalChecked(), ToggleCameraCaptureKeyGetter, ToggleCameraCaptureKeySetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("toggleBroadcastKeyModifiers").ToLocalChecked(), ToggleBroadcastKeyModifiersGetter, ToggleBroadcastKeyModifiersSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("toggleBroadcastKey").ToLocalChecked(), ToggleBroadcastKeyGetter, ToggleBroadcastKeySetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppCaptureAlternateShortcutKeys").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppCaptureAlternateShortcutKeys(::Windows::Media::Capture::AppCaptureAlternateShortcutKeys^ 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::Media::Capture::AppCaptureAlternateShortcutKeys^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureAlternateShortcutKeys^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppCaptureAlternateShortcutKeys^) 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());

      AppCaptureAlternateShortcutKeys *wrapperInstance = new AppCaptureAlternateShortcutKeys(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::Media::Capture::AppCaptureAlternateShortcutKeys^>(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::Media::Capture::AppCaptureAlternateShortcutKeys^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppCaptureAlternateShortcutKeys^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppCaptureAlternateShortcutKeys(winRtInstance));
    }





    static void ToggleRecordingKeyModifiersGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try  {
        ::Windows::System::VirtualKeyModifiers result = wrapper->_instance->ToggleRecordingKeyModifiers;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ToggleRecordingKeyModifiersSetter(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::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try {

        ::Windows::System::VirtualKeyModifiers winRtValue = static_cast<::Windows::System::VirtualKeyModifiers>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->ToggleRecordingKeyModifiers = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ToggleRecordingKeyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try  {
        ::Windows::System::VirtualKey result = wrapper->_instance->ToggleRecordingKey;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ToggleRecordingKeySetter(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::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try {

        ::Windows::System::VirtualKey winRtValue = static_cast<::Windows::System::VirtualKey>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->ToggleRecordingKey = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ToggleRecordingIndicatorKeyModifiersGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try  {
        ::Windows::System::VirtualKeyModifiers result = wrapper->_instance->ToggleRecordingIndicatorKeyModifiers;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ToggleRecordingIndicatorKeyModifiersSetter(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::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try {

        ::Windows::System::VirtualKeyModifiers winRtValue = static_cast<::Windows::System::VirtualKeyModifiers>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->ToggleRecordingIndicatorKeyModifiers = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ToggleRecordingIndicatorKeyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try  {
        ::Windows::System::VirtualKey result = wrapper->_instance->ToggleRecordingIndicatorKey;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ToggleRecordingIndicatorKeySetter(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::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try {

        ::Windows::System::VirtualKey winRtValue = static_cast<::Windows::System::VirtualKey>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->ToggleRecordingIndicatorKey = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ToggleGameBarKeyModifiersGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try  {
        ::Windows::System::VirtualKeyModifiers result = wrapper->_instance->ToggleGameBarKeyModifiers;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ToggleGameBarKeyModifiersSetter(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::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try {

        ::Windows::System::VirtualKeyModifiers winRtValue = static_cast<::Windows::System::VirtualKeyModifiers>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->ToggleGameBarKeyModifiers = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ToggleGameBarKeyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try  {
        ::Windows::System::VirtualKey result = wrapper->_instance->ToggleGameBarKey;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ToggleGameBarKeySetter(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::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try {

        ::Windows::System::VirtualKey winRtValue = static_cast<::Windows::System::VirtualKey>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->ToggleGameBarKey = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void TakeScreenshotKeyModifiersGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try  {
        ::Windows::System::VirtualKeyModifiers result = wrapper->_instance->TakeScreenshotKeyModifiers;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TakeScreenshotKeyModifiersSetter(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::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try {

        ::Windows::System::VirtualKeyModifiers winRtValue = static_cast<::Windows::System::VirtualKeyModifiers>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->TakeScreenshotKeyModifiers = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void TakeScreenshotKeyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try  {
        ::Windows::System::VirtualKey result = wrapper->_instance->TakeScreenshotKey;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TakeScreenshotKeySetter(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::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try {

        ::Windows::System::VirtualKey winRtValue = static_cast<::Windows::System::VirtualKey>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->TakeScreenshotKey = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void SaveHistoricalVideoKeyModifiersGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try  {
        ::Windows::System::VirtualKeyModifiers result = wrapper->_instance->SaveHistoricalVideoKeyModifiers;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SaveHistoricalVideoKeyModifiersSetter(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::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try {

        ::Windows::System::VirtualKeyModifiers winRtValue = static_cast<::Windows::System::VirtualKeyModifiers>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->SaveHistoricalVideoKeyModifiers = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void SaveHistoricalVideoKeyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try  {
        ::Windows::System::VirtualKey result = wrapper->_instance->SaveHistoricalVideoKey;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SaveHistoricalVideoKeySetter(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::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try {

        ::Windows::System::VirtualKey winRtValue = static_cast<::Windows::System::VirtualKey>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->SaveHistoricalVideoKey = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ToggleMicrophoneCaptureKeyModifiersGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try  {
        ::Windows::System::VirtualKeyModifiers result = wrapper->_instance->ToggleMicrophoneCaptureKeyModifiers;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ToggleMicrophoneCaptureKeyModifiersSetter(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::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try {

        ::Windows::System::VirtualKeyModifiers winRtValue = static_cast<::Windows::System::VirtualKeyModifiers>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->ToggleMicrophoneCaptureKeyModifiers = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ToggleMicrophoneCaptureKeyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try  {
        ::Windows::System::VirtualKey result = wrapper->_instance->ToggleMicrophoneCaptureKey;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ToggleMicrophoneCaptureKeySetter(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::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try {

        ::Windows::System::VirtualKey winRtValue = static_cast<::Windows::System::VirtualKey>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->ToggleMicrophoneCaptureKey = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ToggleCameraCaptureKeyModifiersGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try  {
        ::Windows::System::VirtualKeyModifiers result = wrapper->_instance->ToggleCameraCaptureKeyModifiers;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ToggleCameraCaptureKeyModifiersSetter(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::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try {

        ::Windows::System::VirtualKeyModifiers winRtValue = static_cast<::Windows::System::VirtualKeyModifiers>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->ToggleCameraCaptureKeyModifiers = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ToggleCameraCaptureKeyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try  {
        ::Windows::System::VirtualKey result = wrapper->_instance->ToggleCameraCaptureKey;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ToggleCameraCaptureKeySetter(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::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try {

        ::Windows::System::VirtualKey winRtValue = static_cast<::Windows::System::VirtualKey>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->ToggleCameraCaptureKey = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ToggleBroadcastKeyModifiersGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try  {
        ::Windows::System::VirtualKeyModifiers result = wrapper->_instance->ToggleBroadcastKeyModifiers;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ToggleBroadcastKeyModifiersSetter(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::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try {

        ::Windows::System::VirtualKeyModifiers winRtValue = static_cast<::Windows::System::VirtualKeyModifiers>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->ToggleBroadcastKeyModifiers = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void ToggleBroadcastKeyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try  {
        ::Windows::System::VirtualKey result = wrapper->_instance->ToggleBroadcastKey;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ToggleBroadcastKeySetter(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::Media::Capture::AppCaptureAlternateShortcutKeys^>(info.This())) {
        return;
      }

      AppCaptureAlternateShortcutKeys *wrapper = AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(info.This());

      try {

        ::Windows::System::VirtualKey winRtValue = static_cast<::Windows::System::VirtualKey>(Nan::To<int32_t>(value).FromMaybe(0));

        wrapper->_instance->ToggleBroadcastKey = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      


    private:
      ::Windows::Media::Capture::AppCaptureAlternateShortcutKeys^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppCaptureAlternateShortcutKeys(::Windows::Media::Capture::AppCaptureAlternateShortcutKeys^ wintRtInstance);
      friend ::Windows::Media::Capture::AppCaptureAlternateShortcutKeys^ UnwrapAppCaptureAlternateShortcutKeys(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppCaptureAlternateShortcutKeys::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppCaptureAlternateShortcutKeys(::Windows::Media::Capture::AppCaptureAlternateShortcutKeys^ 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>(AppCaptureAlternateShortcutKeys::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppCaptureAlternateShortcutKeys^ UnwrapAppCaptureAlternateShortcutKeys(Local<Value> value) {
     return AppCaptureAlternateShortcutKeys::Unwrap<AppCaptureAlternateShortcutKeys>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppCaptureAlternateShortcutKeys(Local<Object> exports) {
    AppCaptureAlternateShortcutKeys::Init(exports);
  }

  class AppCaptureManager : 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>("AppCaptureManager").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);






        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetMethod(constructor, "getCurrentSettings", GetCurrentSettings);
        Nan::SetMethod(constructor, "applySettings", ApplySettings);


        Nan::Set(exports, Nan::New<String>("AppCaptureManager").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppCaptureManager(::Windows::Media::Capture::AppCaptureManager^ 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::Media::Capture::AppCaptureManager^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureManager^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppCaptureManager^) 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());

      AppCaptureManager *wrapperInstance = new AppCaptureManager(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::Media::Capture::AppCaptureManager^>(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::Media::Capture::AppCaptureManager^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppCaptureManager^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppCaptureManager(winRtInstance));
    }





    static void GetCurrentSettings(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Media::Capture::AppCaptureSettings^ result;
          result = ::Windows::Media::Capture::AppCaptureManager::GetCurrentSettings();
          info.GetReturnValue().Set(WrapAppCaptureSettings(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 ApplySettings(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureSettings^>(info[0]))
      {
        try
        {
          ::Windows::Media::Capture::AppCaptureSettings^ arg0 = UnwrapAppCaptureSettings(info[0]);
          
          ::Windows::Media::Capture::AppCaptureManager::ApplySettings(arg0);
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    private:
      ::Windows::Media::Capture::AppCaptureManager^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppCaptureManager(::Windows::Media::Capture::AppCaptureManager^ wintRtInstance);
      friend ::Windows::Media::Capture::AppCaptureManager^ UnwrapAppCaptureManager(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppCaptureManager::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppCaptureManager(::Windows::Media::Capture::AppCaptureManager^ 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>(AppCaptureManager::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppCaptureManager^ UnwrapAppCaptureManager(Local<Value> value) {
     return AppCaptureManager::Unwrap<AppCaptureManager>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppCaptureManager(Local<Object> exports) {
    AppCaptureManager::Init(exports);
  }

  class AppCaptureRecordOperation : 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>("AppCaptureRecordOperation").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "stopRecording", StopRecording);
          


          
          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>("duration").ToLocalChecked(), DurationGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("errorCode").ToLocalChecked(), ErrorCodeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("file").ToLocalChecked(), FileGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isFileTruncated").ToLocalChecked(), IsFileTruncatedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("state").ToLocalChecked(), StateGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppCaptureRecordOperation").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppCaptureRecordOperation(::Windows::Media::Capture::AppCaptureRecordOperation^ 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::Media::Capture::AppCaptureRecordOperation^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureRecordOperation^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppCaptureRecordOperation^) 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());

      AppCaptureRecordOperation *wrapperInstance = new AppCaptureRecordOperation(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::Media::Capture::AppCaptureRecordOperation^>(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::Media::Capture::AppCaptureRecordOperation^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppCaptureRecordOperation^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppCaptureRecordOperation(winRtInstance));
    }


    static void StopRecording(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureRecordOperation^>(info.This())) {
        return;
      }

      AppCaptureRecordOperation *wrapper = AppCaptureRecordOperation::Unwrap<AppCaptureRecordOperation>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->StopRecording();
          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 DurationGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureRecordOperation^>(info.This())) {
        return;
      }

      AppCaptureRecordOperation *wrapper = AppCaptureRecordOperation::Unwrap<AppCaptureRecordOperation>(info.This());

      try  {
        ::Platform::IBox<::Windows::Foundation::TimeSpan>^ result = wrapper->_instance->Duration;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Number>(result->Value.Duration/10000.0)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ErrorCodeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureRecordOperation^>(info.This())) {
        return;
      }

      AppCaptureRecordOperation *wrapper = AppCaptureRecordOperation::Unwrap<AppCaptureRecordOperation>(info.This());

      try  {
        ::Platform::IBox<unsigned int>^ result = wrapper->_instance->ErrorCode;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Integer>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void FileGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureRecordOperation^>(info.This())) {
        return;
      }

      AppCaptureRecordOperation *wrapper = AppCaptureRecordOperation::Unwrap<AppCaptureRecordOperation>(info.This());

      try  {
        ::Windows::Storage::StorageFile^ result = wrapper->_instance->File;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Storage", "StorageFile", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsFileTruncatedGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureRecordOperation^>(info.This())) {
        return;
      }

      AppCaptureRecordOperation *wrapper = AppCaptureRecordOperation::Unwrap<AppCaptureRecordOperation>(info.This());

      try  {
        ::Platform::IBox<bool>^ result = wrapper->_instance->IsFileTruncated;
        info.GetReturnValue().Set(result ? static_cast<Local<Value>>(Nan::New<Boolean>(result->Value)) : Undefined());
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void StateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureRecordOperation^>(info.This())) {
        return;
      }

      AppCaptureRecordOperation *wrapper = AppCaptureRecordOperation::Unwrap<AppCaptureRecordOperation>(info.This());

      try  {
        ::Windows::Media::Capture::AppCaptureRecordingState result = wrapper->_instance->State;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    static void AddListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"durationGenerated", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureRecordOperation^>(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;
        }
        AppCaptureRecordOperation *wrapper = AppCaptureRecordOperation::Unwrap<AppCaptureRecordOperation>(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->DurationGenerated::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::AppCaptureRecordOperation^, ::Windows::Media::Capture::AppCaptureDurationGeneratedEventArgs^>(
            [callbackObjPtr](::Windows::Media::Capture::AppCaptureRecordOperation^ arg0, ::Windows::Media::Capture::AppCaptureDurationGeneratedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAppCaptureRecordOperation(arg0);
                  wrappedArg1 = WrapAppCaptureDurationGeneratedEventArgs(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"fileGenerated", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureRecordOperation^>(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;
        }
        AppCaptureRecordOperation *wrapper = AppCaptureRecordOperation::Unwrap<AppCaptureRecordOperation>(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->FileGenerated::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::AppCaptureRecordOperation^, ::Windows::Media::Capture::AppCaptureFileGeneratedEventArgs^>(
            [callbackObjPtr](::Windows::Media::Capture::AppCaptureRecordOperation^ arg0, ::Windows::Media::Capture::AppCaptureFileGeneratedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAppCaptureRecordOperation(arg0);
                  wrappedArg1 = WrapAppCaptureFileGeneratedEventArgs(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"stateChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureRecordOperation^>(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;
        }
        AppCaptureRecordOperation *wrapper = AppCaptureRecordOperation::Unwrap<AppCaptureRecordOperation>(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->StateChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::AppCaptureRecordOperation^, ::Windows::Media::Capture::AppCaptureRecordingStateChangedEventArgs^>(
            [callbackObjPtr](::Windows::Media::Capture::AppCaptureRecordOperation^ arg0, ::Windows::Media::Capture::AppCaptureRecordingStateChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAppCaptureRecordOperation(arg0);
                  wrappedArg1 = WrapAppCaptureRecordingStateChangedEventArgs(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"durationGenerated", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"fileGenerated", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"stateChanged", 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"durationGenerated", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureRecordOperation^>(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;
          }
          AppCaptureRecordOperation *wrapper = AppCaptureRecordOperation::Unwrap<AppCaptureRecordOperation>(info.This());
          wrapper->_instance->DurationGenerated::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"fileGenerated", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureRecordOperation^>(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;
          }
          AppCaptureRecordOperation *wrapper = AppCaptureRecordOperation::Unwrap<AppCaptureRecordOperation>(info.This());
          wrapper->_instance->FileGenerated::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"stateChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureRecordOperation^>(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;
          }
          AppCaptureRecordOperation *wrapper = AppCaptureRecordOperation::Unwrap<AppCaptureRecordOperation>(info.This());
          wrapper->_instance->StateChanged::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::Media::Capture::AppCaptureRecordOperation^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppCaptureRecordOperation(::Windows::Media::Capture::AppCaptureRecordOperation^ wintRtInstance);
      friend ::Windows::Media::Capture::AppCaptureRecordOperation^ UnwrapAppCaptureRecordOperation(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppCaptureRecordOperation::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppCaptureRecordOperation(::Windows::Media::Capture::AppCaptureRecordOperation^ 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>(AppCaptureRecordOperation::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppCaptureRecordOperation^ UnwrapAppCaptureRecordOperation(Local<Value> value) {
     return AppCaptureRecordOperation::Unwrap<AppCaptureRecordOperation>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppCaptureRecordOperation(Local<Object> exports) {
    AppCaptureRecordOperation::Init(exports);
  }

  class AppCaptureState : 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>("AppCaptureState").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "restartMicrophoneCapture", RestartMicrophoneCapture);
          


          
          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>("shouldCaptureMicrophone").ToLocalChecked(), ShouldCaptureMicrophoneGetter, ShouldCaptureMicrophoneSetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isHistoricalCaptureEnabled").ToLocalChecked(), IsHistoricalCaptureEnabledGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isTargetRunning").ToLocalChecked(), IsTargetRunningGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("microphoneCaptureError").ToLocalChecked(), MicrophoneCaptureErrorGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("microphoneCaptureState").ToLocalChecked(), MicrophoneCaptureStateGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppCaptureState").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppCaptureState(::Windows::Media::Capture::AppCaptureState^ 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::Media::Capture::AppCaptureState^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureState^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppCaptureState^) 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());

      AppCaptureState *wrapperInstance = new AppCaptureState(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::Media::Capture::AppCaptureState^>(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::Media::Capture::AppCaptureState^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppCaptureState^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppCaptureState(winRtInstance));
    }


    static void RestartMicrophoneCapture(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureState^>(info.This())) {
        return;
      }

      AppCaptureState *wrapper = AppCaptureState::Unwrap<AppCaptureState>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->RestartMicrophoneCapture();
          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 ShouldCaptureMicrophoneGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureState^>(info.This())) {
        return;
      }

      AppCaptureState *wrapper = AppCaptureState::Unwrap<AppCaptureState>(info.This());

      try  {
        bool result = wrapper->_instance->ShouldCaptureMicrophone;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void ShouldCaptureMicrophoneSetter(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::Media::Capture::AppCaptureState^>(info.This())) {
        return;
      }

      AppCaptureState *wrapper = AppCaptureState::Unwrap<AppCaptureState>(info.This());

      try {

        bool winRtValue = Nan::To<bool>(value).FromMaybe(false);

        wrapper->_instance->ShouldCaptureMicrophone = winRtValue;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
      }
    }
      
    static void IsHistoricalCaptureEnabledGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureState^>(info.This())) {
        return;
      }

      AppCaptureState *wrapper = AppCaptureState::Unwrap<AppCaptureState>(info.This());

      try  {
        bool result = wrapper->_instance->IsHistoricalCaptureEnabled;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsTargetRunningGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureState^>(info.This())) {
        return;
      }

      AppCaptureState *wrapper = AppCaptureState::Unwrap<AppCaptureState>(info.This());

      try  {
        bool result = wrapper->_instance->IsTargetRunning;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MicrophoneCaptureErrorGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureState^>(info.This())) {
        return;
      }

      AppCaptureState *wrapper = AppCaptureState::Unwrap<AppCaptureState>(info.This());

      try  {
        unsigned int result = wrapper->_instance->MicrophoneCaptureError;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void MicrophoneCaptureStateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureState^>(info.This())) {
        return;
      }

      AppCaptureState *wrapper = AppCaptureState::Unwrap<AppCaptureState>(info.This());

      try  {
        ::Windows::Media::Capture::AppCaptureMicrophoneCaptureState result = wrapper->_instance->MicrophoneCaptureState;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    static void AddListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"captureTargetClosed", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureState^>(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;
        }
        AppCaptureState *wrapper = AppCaptureState::Unwrap<AppCaptureState>(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->CaptureTargetClosed::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::AppCaptureState^, ::Platform::Object^>(
            [callbackObjPtr](::Windows::Media::Capture::AppCaptureState^ arg0, ::Platform::Object^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAppCaptureState(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"microphoneCaptureStateChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureState^>(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;
        }
        AppCaptureState *wrapper = AppCaptureState::Unwrap<AppCaptureState>(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->MicrophoneCaptureStateChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::AppCaptureState^, ::Windows::Media::Capture::AppCaptureMicrophoneCaptureStateChangedEventArgs^>(
            [callbackObjPtr](::Windows::Media::Capture::AppCaptureState^ arg0, ::Windows::Media::Capture::AppCaptureMicrophoneCaptureStateChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapAppCaptureState(arg0);
                  wrappedArg1 = WrapAppCaptureMicrophoneCaptureStateChangedEventArgs(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"captureTargetClosed", str)) &&(!NodeRT::Utils::CaseInsenstiveEquals(L"microphoneCaptureStateChanged", 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"captureTargetClosed", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureState^>(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;
          }
          AppCaptureState *wrapper = AppCaptureState::Unwrap<AppCaptureState>(info.This());
          wrapper->_instance->CaptureTargetClosed::remove(registrationToken);
        }
        else if (NodeRT::Utils::CaseInsenstiveEquals(L"microphoneCaptureStateChanged", str))
        {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureState^>(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;
          }
          AppCaptureState *wrapper = AppCaptureState::Unwrap<AppCaptureState>(info.This());
          wrapper->_instance->MicrophoneCaptureStateChanged::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::Media::Capture::AppCaptureState^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppCaptureState(::Windows::Media::Capture::AppCaptureState^ wintRtInstance);
      friend ::Windows::Media::Capture::AppCaptureState^ UnwrapAppCaptureState(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppCaptureState::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppCaptureState(::Windows::Media::Capture::AppCaptureState^ 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>(AppCaptureState::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppCaptureState^ UnwrapAppCaptureState(Local<Value> value) {
     return AppCaptureState::Unwrap<AppCaptureState>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppCaptureState(Local<Object> exports) {
    AppCaptureState::Init(exports);
  }

  class AppCaptureMicrophoneCaptureStateChangedEventArgs : 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>("AppCaptureMicrophoneCaptureStateChangedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("errorCode").ToLocalChecked(), ErrorCodeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("state").ToLocalChecked(), StateGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppCaptureMicrophoneCaptureStateChangedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppCaptureMicrophoneCaptureStateChangedEventArgs(::Windows::Media::Capture::AppCaptureMicrophoneCaptureStateChangedEventArgs^ 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::Media::Capture::AppCaptureMicrophoneCaptureStateChangedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureMicrophoneCaptureStateChangedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppCaptureMicrophoneCaptureStateChangedEventArgs^) 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());

      AppCaptureMicrophoneCaptureStateChangedEventArgs *wrapperInstance = new AppCaptureMicrophoneCaptureStateChangedEventArgs(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::Media::Capture::AppCaptureMicrophoneCaptureStateChangedEventArgs^>(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::Media::Capture::AppCaptureMicrophoneCaptureStateChangedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppCaptureMicrophoneCaptureStateChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppCaptureMicrophoneCaptureStateChangedEventArgs(winRtInstance));
    }





    static void ErrorCodeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureMicrophoneCaptureStateChangedEventArgs^>(info.This())) {
        return;
      }

      AppCaptureMicrophoneCaptureStateChangedEventArgs *wrapper = AppCaptureMicrophoneCaptureStateChangedEventArgs::Unwrap<AppCaptureMicrophoneCaptureStateChangedEventArgs>(info.This());

      try  {
        unsigned int result = wrapper->_instance->ErrorCode;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void StateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureMicrophoneCaptureStateChangedEventArgs^>(info.This())) {
        return;
      }

      AppCaptureMicrophoneCaptureStateChangedEventArgs *wrapper = AppCaptureMicrophoneCaptureStateChangedEventArgs::Unwrap<AppCaptureMicrophoneCaptureStateChangedEventArgs>(info.This());

      try  {
        ::Windows::Media::Capture::AppCaptureMicrophoneCaptureState result = wrapper->_instance->State;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::AppCaptureMicrophoneCaptureStateChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppCaptureMicrophoneCaptureStateChangedEventArgs(::Windows::Media::Capture::AppCaptureMicrophoneCaptureStateChangedEventArgs^ wintRtInstance);
      friend ::Windows::Media::Capture::AppCaptureMicrophoneCaptureStateChangedEventArgs^ UnwrapAppCaptureMicrophoneCaptureStateChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppCaptureMicrophoneCaptureStateChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppCaptureMicrophoneCaptureStateChangedEventArgs(::Windows::Media::Capture::AppCaptureMicrophoneCaptureStateChangedEventArgs^ 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>(AppCaptureMicrophoneCaptureStateChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppCaptureMicrophoneCaptureStateChangedEventArgs^ UnwrapAppCaptureMicrophoneCaptureStateChangedEventArgs(Local<Value> value) {
     return AppCaptureMicrophoneCaptureStateChangedEventArgs::Unwrap<AppCaptureMicrophoneCaptureStateChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppCaptureMicrophoneCaptureStateChangedEventArgs(Local<Object> exports) {
    AppCaptureMicrophoneCaptureStateChangedEventArgs::Init(exports);
  }

  class AppCaptureRecordingStateChangedEventArgs : 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>("AppCaptureRecordingStateChangedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("errorCode").ToLocalChecked(), ErrorCodeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("state").ToLocalChecked(), StateGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppCaptureRecordingStateChangedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppCaptureRecordingStateChangedEventArgs(::Windows::Media::Capture::AppCaptureRecordingStateChangedEventArgs^ 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::Media::Capture::AppCaptureRecordingStateChangedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureRecordingStateChangedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppCaptureRecordingStateChangedEventArgs^) 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());

      AppCaptureRecordingStateChangedEventArgs *wrapperInstance = new AppCaptureRecordingStateChangedEventArgs(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::Media::Capture::AppCaptureRecordingStateChangedEventArgs^>(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::Media::Capture::AppCaptureRecordingStateChangedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppCaptureRecordingStateChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppCaptureRecordingStateChangedEventArgs(winRtInstance));
    }





    static void ErrorCodeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureRecordingStateChangedEventArgs^>(info.This())) {
        return;
      }

      AppCaptureRecordingStateChangedEventArgs *wrapper = AppCaptureRecordingStateChangedEventArgs::Unwrap<AppCaptureRecordingStateChangedEventArgs>(info.This());

      try  {
        unsigned int result = wrapper->_instance->ErrorCode;
        info.GetReturnValue().Set(Nan::New<Integer>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void StateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureRecordingStateChangedEventArgs^>(info.This())) {
        return;
      }

      AppCaptureRecordingStateChangedEventArgs *wrapper = AppCaptureRecordingStateChangedEventArgs::Unwrap<AppCaptureRecordingStateChangedEventArgs>(info.This());

      try  {
        ::Windows::Media::Capture::AppCaptureRecordingState result = wrapper->_instance->State;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::AppCaptureRecordingStateChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppCaptureRecordingStateChangedEventArgs(::Windows::Media::Capture::AppCaptureRecordingStateChangedEventArgs^ wintRtInstance);
      friend ::Windows::Media::Capture::AppCaptureRecordingStateChangedEventArgs^ UnwrapAppCaptureRecordingStateChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppCaptureRecordingStateChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppCaptureRecordingStateChangedEventArgs(::Windows::Media::Capture::AppCaptureRecordingStateChangedEventArgs^ 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>(AppCaptureRecordingStateChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppCaptureRecordingStateChangedEventArgs^ UnwrapAppCaptureRecordingStateChangedEventArgs(Local<Value> value) {
     return AppCaptureRecordingStateChangedEventArgs::Unwrap<AppCaptureRecordingStateChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppCaptureRecordingStateChangedEventArgs(Local<Object> exports) {
    AppCaptureRecordingStateChangedEventArgs::Init(exports);
  }

  class AppCaptureDurationGeneratedEventArgs : 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>("AppCaptureDurationGeneratedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("duration").ToLocalChecked(), DurationGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppCaptureDurationGeneratedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppCaptureDurationGeneratedEventArgs(::Windows::Media::Capture::AppCaptureDurationGeneratedEventArgs^ 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::Media::Capture::AppCaptureDurationGeneratedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureDurationGeneratedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppCaptureDurationGeneratedEventArgs^) 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());

      AppCaptureDurationGeneratedEventArgs *wrapperInstance = new AppCaptureDurationGeneratedEventArgs(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::Media::Capture::AppCaptureDurationGeneratedEventArgs^>(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::Media::Capture::AppCaptureDurationGeneratedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppCaptureDurationGeneratedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppCaptureDurationGeneratedEventArgs(winRtInstance));
    }





    static void DurationGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureDurationGeneratedEventArgs^>(info.This())) {
        return;
      }

      AppCaptureDurationGeneratedEventArgs *wrapper = AppCaptureDurationGeneratedEventArgs::Unwrap<AppCaptureDurationGeneratedEventArgs>(info.This());

      try  {
        ::Windows::Foundation::TimeSpan result = wrapper->_instance->Duration;
        info.GetReturnValue().Set(Nan::New<Number>(result.Duration/10000.0));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::AppCaptureDurationGeneratedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppCaptureDurationGeneratedEventArgs(::Windows::Media::Capture::AppCaptureDurationGeneratedEventArgs^ wintRtInstance);
      friend ::Windows::Media::Capture::AppCaptureDurationGeneratedEventArgs^ UnwrapAppCaptureDurationGeneratedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppCaptureDurationGeneratedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppCaptureDurationGeneratedEventArgs(::Windows::Media::Capture::AppCaptureDurationGeneratedEventArgs^ 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>(AppCaptureDurationGeneratedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppCaptureDurationGeneratedEventArgs^ UnwrapAppCaptureDurationGeneratedEventArgs(Local<Value> value) {
     return AppCaptureDurationGeneratedEventArgs::Unwrap<AppCaptureDurationGeneratedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppCaptureDurationGeneratedEventArgs(Local<Object> exports) {
    AppCaptureDurationGeneratedEventArgs::Init(exports);
  }

  class AppCaptureFileGeneratedEventArgs : 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>("AppCaptureFileGeneratedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("file").ToLocalChecked(), FileGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppCaptureFileGeneratedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppCaptureFileGeneratedEventArgs(::Windows::Media::Capture::AppCaptureFileGeneratedEventArgs^ 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::Media::Capture::AppCaptureFileGeneratedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureFileGeneratedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppCaptureFileGeneratedEventArgs^) 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());

      AppCaptureFileGeneratedEventArgs *wrapperInstance = new AppCaptureFileGeneratedEventArgs(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::Media::Capture::AppCaptureFileGeneratedEventArgs^>(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::Media::Capture::AppCaptureFileGeneratedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppCaptureFileGeneratedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppCaptureFileGeneratedEventArgs(winRtInstance));
    }





    static void FileGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureFileGeneratedEventArgs^>(info.This())) {
        return;
      }

      AppCaptureFileGeneratedEventArgs *wrapper = AppCaptureFileGeneratedEventArgs::Unwrap<AppCaptureFileGeneratedEventArgs>(info.This());

      try  {
        ::Windows::Storage::StorageFile^ result = wrapper->_instance->File;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Storage", "StorageFile", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::AppCaptureFileGeneratedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppCaptureFileGeneratedEventArgs(::Windows::Media::Capture::AppCaptureFileGeneratedEventArgs^ wintRtInstance);
      friend ::Windows::Media::Capture::AppCaptureFileGeneratedEventArgs^ UnwrapAppCaptureFileGeneratedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppCaptureFileGeneratedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppCaptureFileGeneratedEventArgs(::Windows::Media::Capture::AppCaptureFileGeneratedEventArgs^ 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>(AppCaptureFileGeneratedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppCaptureFileGeneratedEventArgs^ UnwrapAppCaptureFileGeneratedEventArgs(Local<Value> value) {
     return AppCaptureFileGeneratedEventArgs::Unwrap<AppCaptureFileGeneratedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppCaptureFileGeneratedEventArgs(Local<Object> exports) {
    AppCaptureFileGeneratedEventArgs::Init(exports);
  }

  class AppCaptureServices : 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>("AppCaptureServices").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "record", Record);
            Nan::SetPrototypeMethod(localRef, "recordTimeSpan", RecordTimeSpan);
          



          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("canCapture").ToLocalChecked(), CanCaptureGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("state").ToLocalChecked(), StateGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("AppCaptureServices").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      AppCaptureServices(::Windows::Media::Capture::AppCaptureServices^ 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::Media::Capture::AppCaptureServices^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureServices^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::AppCaptureServices^) 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());

      AppCaptureServices *wrapperInstance = new AppCaptureServices(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::Media::Capture::AppCaptureServices^>(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::Media::Capture::AppCaptureServices^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::AppCaptureServices^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapAppCaptureServices(winRtInstance));
    }


    static void Record(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureServices^>(info.This())) {
        return;
      }

      AppCaptureServices *wrapper = AppCaptureServices::Unwrap<AppCaptureServices>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Media::Capture::AppCaptureRecordOperation^ result;
          result = wrapper->_instance->Record();
          info.GetReturnValue().Set(WrapAppCaptureRecordOperation(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 RecordTimeSpan(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureServices^>(info.This())) {
        return;
      }

      AppCaptureServices *wrapper = AppCaptureServices::Unwrap<AppCaptureServices>(info.This());

      if (info.Length() == 2
        && info[0]->IsDate()
        && info[1]->IsNumber())
      {
        try
        {
          ::Windows::Foundation::DateTime arg0 = NodeRT::Utils::DateTimeFromJSDate(info[0]);
          ::Windows::Foundation::TimeSpan arg1 = NodeRT::Utils::TimeSpanFromMilli(Nan::To<int64_t>(info[1]).FromMaybe(0));
          
          ::Windows::Media::Capture::AppCaptureRecordOperation^ result;
          result = wrapper->_instance->RecordTimeSpan(arg0, arg1);
          info.GetReturnValue().Set(WrapAppCaptureRecordOperation(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 CanCaptureGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureServices^>(info.This())) {
        return;
      }

      AppCaptureServices *wrapper = AppCaptureServices::Unwrap<AppCaptureServices>(info.This());

      try  {
        bool result = wrapper->_instance->CanCapture;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void StateGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::AppCaptureServices^>(info.This())) {
        return;
      }

      AppCaptureServices *wrapper = AppCaptureServices::Unwrap<AppCaptureServices>(info.This());

      try  {
        ::Windows::Media::Capture::AppCaptureState^ result = wrapper->_instance->State;
        info.GetReturnValue().Set(WrapAppCaptureState(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::AppCaptureServices^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapAppCaptureServices(::Windows::Media::Capture::AppCaptureServices^ wintRtInstance);
      friend ::Windows::Media::Capture::AppCaptureServices^ UnwrapAppCaptureServices(Local<Value> value);
  };

  Persistent<FunctionTemplate> AppCaptureServices::s_constructorTemplate;

  v8::Local<v8::Value> WrapAppCaptureServices(::Windows::Media::Capture::AppCaptureServices^ 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>(AppCaptureServices::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::AppCaptureServices^ UnwrapAppCaptureServices(Local<Value> value) {
     return AppCaptureServices::Unwrap<AppCaptureServices>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitAppCaptureServices(Local<Object> exports) {
    AppCaptureServices::Init(exports);
  }

  class CameraOptionsUI : 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>("CameraOptionsUI").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);






        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetMethod(constructor, "show", Show);


        Nan::Set(exports, Nan::New<String>("CameraOptionsUI").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      CameraOptionsUI(::Windows::Media::Capture::CameraOptionsUI^ 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::Media::Capture::CameraOptionsUI^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::CameraOptionsUI^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::CameraOptionsUI^) 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());

      CameraOptionsUI *wrapperInstance = new CameraOptionsUI(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::Media::Capture::CameraOptionsUI^>(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::Media::Capture::CameraOptionsUI^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::CameraOptionsUI^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapCameraOptionsUI(winRtInstance));
    }





    static void Show(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 1
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::MediaCapture^>(info[0]))
      {
        try
        {
          ::Windows::Media::Capture::MediaCapture^ arg0 = UnwrapMediaCapture(info[0]);
          
          ::Windows::Media::Capture::CameraOptionsUI::Show(arg0);
          return;
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
 else  {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"Bad arguments: no suitable overload found")));
        return;
      }
    }



    private:
      ::Windows::Media::Capture::CameraOptionsUI^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapCameraOptionsUI(::Windows::Media::Capture::CameraOptionsUI^ wintRtInstance);
      friend ::Windows::Media::Capture::CameraOptionsUI^ UnwrapCameraOptionsUI(Local<Value> value);
  };

  Persistent<FunctionTemplate> CameraOptionsUI::s_constructorTemplate;

  v8::Local<v8::Value> WrapCameraOptionsUI(::Windows::Media::Capture::CameraOptionsUI^ 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>(CameraOptionsUI::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::CameraOptionsUI^ UnwrapCameraOptionsUI(Local<Value> value) {
     return CameraOptionsUI::Unwrap<CameraOptionsUI>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitCameraOptionsUI(Local<Object> exports) {
    CameraOptionsUI::Init(exports);
  }

  class GameBarServicesManager : 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>("GameBarServicesManager").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);




          
          Nan::SetPrototypeMethod(localRef,"addListener", AddListener);
          Nan::SetPrototypeMethod(localRef,"on", AddListener);
          Nan::SetPrototypeMethod(localRef,"removeListener", RemoveListener);
          Nan::SetPrototypeMethod(localRef, "off", RemoveListener);


        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetMethod(constructor, "getDefault", GetDefault);


        Nan::Set(exports, Nan::New<String>("GameBarServicesManager").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      GameBarServicesManager(::Windows::Media::Capture::GameBarServicesManager^ 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::Media::Capture::GameBarServicesManager^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::GameBarServicesManager^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::GameBarServicesManager^) 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());

      GameBarServicesManager *wrapperInstance = new GameBarServicesManager(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::Media::Capture::GameBarServicesManager^>(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::Media::Capture::GameBarServicesManager^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::GameBarServicesManager^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapGameBarServicesManager(winRtInstance));
    }





    static void GetDefault(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Media::Capture::GameBarServicesManager^ result;
          result = ::Windows::Media::Capture::GameBarServicesManager::GetDefault();
          info.GetReturnValue().Set(WrapGameBarServicesManager(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"gameBarServicesCreated", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::GameBarServicesManager^>(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;
        }
        GameBarServicesManager *wrapper = GameBarServicesManager::Unwrap<GameBarServicesManager>(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->GameBarServicesCreated::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::GameBarServicesManager^, ::Windows::Media::Capture::GameBarServicesManagerGameBarServicesCreatedEventArgs^>(
            [callbackObjPtr](::Windows::Media::Capture::GameBarServicesManager^ arg0, ::Windows::Media::Capture::GameBarServicesManagerGameBarServicesCreatedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapGameBarServicesManager(arg0);
                  wrappedArg1 = WrapGameBarServicesManagerGameBarServicesCreatedEventArgs(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"gameBarServicesCreated", 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"gameBarServicesCreated", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::GameBarServicesManager^>(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;
          }
          GameBarServicesManager *wrapper = GameBarServicesManager::Unwrap<GameBarServicesManager>(info.This());
          wrapper->_instance->GameBarServicesCreated::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::Media::Capture::GameBarServicesManager^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapGameBarServicesManager(::Windows::Media::Capture::GameBarServicesManager^ wintRtInstance);
      friend ::Windows::Media::Capture::GameBarServicesManager^ UnwrapGameBarServicesManager(Local<Value> value);
  };

  Persistent<FunctionTemplate> GameBarServicesManager::s_constructorTemplate;

  v8::Local<v8::Value> WrapGameBarServicesManager(::Windows::Media::Capture::GameBarServicesManager^ 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>(GameBarServicesManager::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::GameBarServicesManager^ UnwrapGameBarServicesManager(Local<Value> value) {
     return GameBarServicesManager::Unwrap<GameBarServicesManager>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitGameBarServicesManager(Local<Object> exports) {
    GameBarServicesManager::Init(exports);
  }

  class GameBarServicesManagerGameBarServicesCreatedEventArgs : 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>("GameBarServicesManagerGameBarServicesCreatedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("gameBarServices").ToLocalChecked(), GameBarServicesGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("GameBarServicesManagerGameBarServicesCreatedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      GameBarServicesManagerGameBarServicesCreatedEventArgs(::Windows::Media::Capture::GameBarServicesManagerGameBarServicesCreatedEventArgs^ 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::Media::Capture::GameBarServicesManagerGameBarServicesCreatedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::GameBarServicesManagerGameBarServicesCreatedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::GameBarServicesManagerGameBarServicesCreatedEventArgs^) 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());

      GameBarServicesManagerGameBarServicesCreatedEventArgs *wrapperInstance = new GameBarServicesManagerGameBarServicesCreatedEventArgs(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::Media::Capture::GameBarServicesManagerGameBarServicesCreatedEventArgs^>(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::Media::Capture::GameBarServicesManagerGameBarServicesCreatedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::GameBarServicesManagerGameBarServicesCreatedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapGameBarServicesManagerGameBarServicesCreatedEventArgs(winRtInstance));
    }





    static void GameBarServicesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::GameBarServicesManagerGameBarServicesCreatedEventArgs^>(info.This())) {
        return;
      }

      GameBarServicesManagerGameBarServicesCreatedEventArgs *wrapper = GameBarServicesManagerGameBarServicesCreatedEventArgs::Unwrap<GameBarServicesManagerGameBarServicesCreatedEventArgs>(info.This());

      try  {
        ::Windows::Media::Capture::GameBarServices^ result = wrapper->_instance->GameBarServices;
        info.GetReturnValue().Set(WrapGameBarServices(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::GameBarServicesManagerGameBarServicesCreatedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapGameBarServicesManagerGameBarServicesCreatedEventArgs(::Windows::Media::Capture::GameBarServicesManagerGameBarServicesCreatedEventArgs^ wintRtInstance);
      friend ::Windows::Media::Capture::GameBarServicesManagerGameBarServicesCreatedEventArgs^ UnwrapGameBarServicesManagerGameBarServicesCreatedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> GameBarServicesManagerGameBarServicesCreatedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapGameBarServicesManagerGameBarServicesCreatedEventArgs(::Windows::Media::Capture::GameBarServicesManagerGameBarServicesCreatedEventArgs^ 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>(GameBarServicesManagerGameBarServicesCreatedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::GameBarServicesManagerGameBarServicesCreatedEventArgs^ UnwrapGameBarServicesManagerGameBarServicesCreatedEventArgs(Local<Value> value) {
     return GameBarServicesManagerGameBarServicesCreatedEventArgs::Unwrap<GameBarServicesManagerGameBarServicesCreatedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitGameBarServicesManagerGameBarServicesCreatedEventArgs(Local<Object> exports) {
    GameBarServicesManagerGameBarServicesCreatedEventArgs::Init(exports);
  }

  class GameBarServices : 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>("GameBarServices").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);


          
            Nan::SetPrototypeMethod(localRef, "enableCapture", EnableCapture);
            Nan::SetPrototypeMethod(localRef, "disableCapture", DisableCapture);
          


          
          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>("appBroadcastServices").ToLocalChecked(), AppBroadcastServicesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("appCaptureServices").ToLocalChecked(), AppCaptureServicesGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("sessionId").ToLocalChecked(), SessionIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("targetCapturePolicy").ToLocalChecked(), TargetCapturePolicyGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("targetInfo").ToLocalChecked(), TargetInfoGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("GameBarServices").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      GameBarServices(::Windows::Media::Capture::GameBarServices^ 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::Media::Capture::GameBarServices^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::GameBarServices^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::GameBarServices^) 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());

      GameBarServices *wrapperInstance = new GameBarServices(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::Media::Capture::GameBarServices^>(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::Media::Capture::GameBarServices^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::GameBarServices^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapGameBarServices(winRtInstance));
    }


    static void EnableCapture(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::GameBarServices^>(info.This())) {
        return;
      }

      GameBarServices *wrapper = GameBarServices::Unwrap<GameBarServices>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->EnableCapture();
          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 DisableCapture(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::GameBarServices^>(info.This())) {
        return;
      }

      GameBarServices *wrapper = GameBarServices::Unwrap<GameBarServices>(info.This());

      if (info.Length() == 0)
      {
        try
        {
          wrapper->_instance->DisableCapture();
          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 AppBroadcastServicesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::GameBarServices^>(info.This())) {
        return;
      }

      GameBarServices *wrapper = GameBarServices::Unwrap<GameBarServices>(info.This());

      try  {
        ::Windows::Media::Capture::AppBroadcastServices^ result = wrapper->_instance->AppBroadcastServices;
        info.GetReturnValue().Set(WrapAppBroadcastServices(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void AppCaptureServicesGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::GameBarServices^>(info.This())) {
        return;
      }

      GameBarServices *wrapper = GameBarServices::Unwrap<GameBarServices>(info.This());

      try  {
        ::Windows::Media::Capture::AppCaptureServices^ result = wrapper->_instance->AppCaptureServices;
        info.GetReturnValue().Set(WrapAppCaptureServices(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void SessionIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::GameBarServices^>(info.This())) {
        return;
      }

      GameBarServices *wrapper = GameBarServices::Unwrap<GameBarServices>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->SessionId;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TargetCapturePolicyGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::GameBarServices^>(info.This())) {
        return;
      }

      GameBarServices *wrapper = GameBarServices::Unwrap<GameBarServices>(info.This());

      try  {
        ::Windows::Media::Capture::GameBarTargetCapturePolicy result = wrapper->_instance->TargetCapturePolicy;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TargetInfoGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::GameBarServices^>(info.This())) {
        return;
      }

      GameBarServices *wrapper = GameBarServices::Unwrap<GameBarServices>(info.This());

      try  {
        ::Windows::Media::Capture::GameBarServicesTargetInfo^ result = wrapper->_instance->TargetInfo;
        info.GetReturnValue().Set(WrapGameBarServicesTargetInfo(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    static void AddListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"commandReceived", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::GameBarServices^>(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;
        }
        GameBarServices *wrapper = GameBarServices::Unwrap<GameBarServices>(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->CommandReceived::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::GameBarServices^, ::Windows::Media::Capture::GameBarServicesCommandEventArgs^>(
            [callbackObjPtr](::Windows::Media::Capture::GameBarServices^ arg0, ::Windows::Media::Capture::GameBarServicesCommandEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapGameBarServices(arg0);
                  wrappedArg1 = WrapGameBarServicesCommandEventArgs(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"commandReceived", 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"commandReceived", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::GameBarServices^>(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;
          }
          GameBarServices *wrapper = GameBarServices::Unwrap<GameBarServices>(info.This());
          wrapper->_instance->CommandReceived::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::Media::Capture::GameBarServices^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapGameBarServices(::Windows::Media::Capture::GameBarServices^ wintRtInstance);
      friend ::Windows::Media::Capture::GameBarServices^ UnwrapGameBarServices(Local<Value> value);
  };

  Persistent<FunctionTemplate> GameBarServices::s_constructorTemplate;

  v8::Local<v8::Value> WrapGameBarServices(::Windows::Media::Capture::GameBarServices^ 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>(GameBarServices::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::GameBarServices^ UnwrapGameBarServices(Local<Value> value) {
     return GameBarServices::Unwrap<GameBarServices>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitGameBarServices(Local<Object> exports) {
    GameBarServices::Init(exports);
  }

  class GameBarServicesTargetInfo : 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>("GameBarServicesTargetInfo").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("appId").ToLocalChecked(), AppIdGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("displayMode").ToLocalChecked(), DisplayModeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("displayName").ToLocalChecked(), DisplayNameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("titleId").ToLocalChecked(), TitleIdGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("GameBarServicesTargetInfo").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      GameBarServicesTargetInfo(::Windows::Media::Capture::GameBarServicesTargetInfo^ 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::Media::Capture::GameBarServicesTargetInfo^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::GameBarServicesTargetInfo^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::GameBarServicesTargetInfo^) 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());

      GameBarServicesTargetInfo *wrapperInstance = new GameBarServicesTargetInfo(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::Media::Capture::GameBarServicesTargetInfo^>(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::Media::Capture::GameBarServicesTargetInfo^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::GameBarServicesTargetInfo^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapGameBarServicesTargetInfo(winRtInstance));
    }





    static void AppIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::GameBarServicesTargetInfo^>(info.This())) {
        return;
      }

      GameBarServicesTargetInfo *wrapper = GameBarServicesTargetInfo::Unwrap<GameBarServicesTargetInfo>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->AppId;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DisplayModeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::GameBarServicesTargetInfo^>(info.This())) {
        return;
      }

      GameBarServicesTargetInfo *wrapper = GameBarServicesTargetInfo::Unwrap<GameBarServicesTargetInfo>(info.This());

      try  {
        ::Windows::Media::Capture::GameBarServicesDisplayMode result = wrapper->_instance->DisplayMode;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void DisplayNameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::GameBarServicesTargetInfo^>(info.This())) {
        return;
      }

      GameBarServicesTargetInfo *wrapper = GameBarServicesTargetInfo::Unwrap<GameBarServicesTargetInfo>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->DisplayName;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void TitleIdGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::GameBarServicesTargetInfo^>(info.This())) {
        return;
      }

      GameBarServicesTargetInfo *wrapper = GameBarServicesTargetInfo::Unwrap<GameBarServicesTargetInfo>(info.This());

      try  {
        Platform::String^ result = wrapper->_instance->TitleId;
        info.GetReturnValue().Set(NodeRT::Utils::NewString(result->Data()));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::GameBarServicesTargetInfo^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapGameBarServicesTargetInfo(::Windows::Media::Capture::GameBarServicesTargetInfo^ wintRtInstance);
      friend ::Windows::Media::Capture::GameBarServicesTargetInfo^ UnwrapGameBarServicesTargetInfo(Local<Value> value);
  };

  Persistent<FunctionTemplate> GameBarServicesTargetInfo::s_constructorTemplate;

  v8::Local<v8::Value> WrapGameBarServicesTargetInfo(::Windows::Media::Capture::GameBarServicesTargetInfo^ 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>(GameBarServicesTargetInfo::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::GameBarServicesTargetInfo^ UnwrapGameBarServicesTargetInfo(Local<Value> value) {
     return GameBarServicesTargetInfo::Unwrap<GameBarServicesTargetInfo>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitGameBarServicesTargetInfo(Local<Object> exports) {
    GameBarServicesTargetInfo::Init(exports);
  }

  class GameBarServicesCommandEventArgs : 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>("GameBarServicesCommandEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("command").ToLocalChecked(), CommandGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("origin").ToLocalChecked(), OriginGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("GameBarServicesCommandEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      GameBarServicesCommandEventArgs(::Windows::Media::Capture::GameBarServicesCommandEventArgs^ 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::Media::Capture::GameBarServicesCommandEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::GameBarServicesCommandEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::GameBarServicesCommandEventArgs^) 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());

      GameBarServicesCommandEventArgs *wrapperInstance = new GameBarServicesCommandEventArgs(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::Media::Capture::GameBarServicesCommandEventArgs^>(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::Media::Capture::GameBarServicesCommandEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::GameBarServicesCommandEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapGameBarServicesCommandEventArgs(winRtInstance));
    }





    static void CommandGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::GameBarServicesCommandEventArgs^>(info.This())) {
        return;
      }

      GameBarServicesCommandEventArgs *wrapper = GameBarServicesCommandEventArgs::Unwrap<GameBarServicesCommandEventArgs>(info.This());

      try  {
        ::Windows::Media::Capture::GameBarCommand result = wrapper->_instance->Command;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void OriginGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::GameBarServicesCommandEventArgs^>(info.This())) {
        return;
      }

      GameBarServicesCommandEventArgs *wrapper = GameBarServicesCommandEventArgs::Unwrap<GameBarServicesCommandEventArgs>(info.This());

      try  {
        ::Windows::Media::Capture::GameBarCommandOrigin result = wrapper->_instance->Origin;
        info.GetReturnValue().Set(Nan::New<Integer>(static_cast<int>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::GameBarServicesCommandEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapGameBarServicesCommandEventArgs(::Windows::Media::Capture::GameBarServicesCommandEventArgs^ wintRtInstance);
      friend ::Windows::Media::Capture::GameBarServicesCommandEventArgs^ UnwrapGameBarServicesCommandEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> GameBarServicesCommandEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapGameBarServicesCommandEventArgs(::Windows::Media::Capture::GameBarServicesCommandEventArgs^ 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>(GameBarServicesCommandEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::GameBarServicesCommandEventArgs^ UnwrapGameBarServicesCommandEventArgs(Local<Value> value) {
     return GameBarServicesCommandEventArgs::Unwrap<GameBarServicesCommandEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitGameBarServicesCommandEventArgs(Local<Object> exports) {
    GameBarServicesCommandEventArgs::Init(exports);
  }

  class ScreenCapture : 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>("ScreenCapture").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>("audioSource").ToLocalChecked(), AudioSourceGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isAudioSuspended").ToLocalChecked(), IsAudioSuspendedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isVideoSuspended").ToLocalChecked(), IsVideoSuspendedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("videoSource").ToLocalChecked(), VideoSourceGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);

        Nan::SetMethod(constructor, "getForCurrentView", GetForCurrentView);


        Nan::Set(exports, Nan::New<String>("ScreenCapture").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      ScreenCapture(::Windows::Media::Capture::ScreenCapture^ 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::Media::Capture::ScreenCapture^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::ScreenCapture^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::ScreenCapture^) 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());

      ScreenCapture *wrapperInstance = new ScreenCapture(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::Media::Capture::ScreenCapture^>(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::Media::Capture::ScreenCapture^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::ScreenCapture^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapScreenCapture(winRtInstance));
    }





    static void GetForCurrentView(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Media::Capture::ScreenCapture^ result;
          result = ::Windows::Media::Capture::ScreenCapture::GetForCurrentView();
          info.GetReturnValue().Set(WrapScreenCapture(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 AudioSourceGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::ScreenCapture^>(info.This())) {
        return;
      }

      ScreenCapture *wrapper = ScreenCapture::Unwrap<ScreenCapture>(info.This());

      try  {
        ::Windows::Media::Core::IMediaSource^ result = wrapper->_instance->AudioSource;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Media.Core", "IMediaSource", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsAudioSuspendedGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::ScreenCapture^>(info.This())) {
        return;
      }

      ScreenCapture *wrapper = ScreenCapture::Unwrap<ScreenCapture>(info.This());

      try  {
        bool result = wrapper->_instance->IsAudioSuspended;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsVideoSuspendedGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::ScreenCapture^>(info.This())) {
        return;
      }

      ScreenCapture *wrapper = ScreenCapture::Unwrap<ScreenCapture>(info.This());

      try  {
        bool result = wrapper->_instance->IsVideoSuspended;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void VideoSourceGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::ScreenCapture^>(info.This())) {
        return;
      }

      ScreenCapture *wrapper = ScreenCapture::Unwrap<ScreenCapture>(info.This());

      try  {
        ::Windows::Media::Core::IMediaSource^ result = wrapper->_instance->VideoSource;
        info.GetReturnValue().Set(NodeRT::Utils::CreateExternalWinRTObject("Windows.Media.Core", "IMediaSource", result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    static void AddListener(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (info.Length() < 2 || !info[0]->IsString() || !info[1]->IsFunction()) {
        Nan::ThrowError(Nan::Error(NodeRT::Utils::NewString(L"wrong arguments, expected arguments are eventName(string),callback(function)")));
        return;
      }

      String::Value eventName(v8::Isolate::GetCurrent(), info[0]);
      auto str = *eventName;

      Local<Function> callback = info[1].As<Function>();

      ::Windows::Foundation::EventRegistrationToken registrationToken;
      if (NodeRT::Utils::CaseInsenstiveEquals(L"sourceSuspensionChanged", str))
      {
        if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::ScreenCapture^>(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;
        }
        ScreenCapture *wrapper = ScreenCapture::Unwrap<ScreenCapture>(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->SourceSuspensionChanged::add(
            ref new ::Windows::Foundation::TypedEventHandler<::Windows::Media::Capture::ScreenCapture^, ::Windows::Media::Capture::SourceSuspensionChangedEventArgs^>(
            [callbackObjPtr](::Windows::Media::Capture::ScreenCapture^ arg0, ::Windows::Media::Capture::SourceSuspensionChangedEventArgs^ arg1) {
              NodeUtils::Async::RunOnMain([callbackObjPtr , arg0, arg1]() {
                HandleScope scope;


                Local<Value> wrappedArg0;
                Local<Value> wrappedArg1;

                {
                  TryCatch tryCatch;


                  wrappedArg0 = WrapScreenCapture(arg0);
                  wrappedArg1 = WrapSourceSuspensionChangedEventArgs(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"sourceSuspensionChanged", 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"sourceSuspensionChanged", str)) {
          if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::ScreenCapture^>(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;
          }
          ScreenCapture *wrapper = ScreenCapture::Unwrap<ScreenCapture>(info.This());
          wrapper->_instance->SourceSuspensionChanged::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::Media::Capture::ScreenCapture^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapScreenCapture(::Windows::Media::Capture::ScreenCapture^ wintRtInstance);
      friend ::Windows::Media::Capture::ScreenCapture^ UnwrapScreenCapture(Local<Value> value);
  };

  Persistent<FunctionTemplate> ScreenCapture::s_constructorTemplate;

  v8::Local<v8::Value> WrapScreenCapture(::Windows::Media::Capture::ScreenCapture^ 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>(ScreenCapture::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::ScreenCapture^ UnwrapScreenCapture(Local<Value> value) {
     return ScreenCapture::Unwrap<ScreenCapture>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitScreenCapture(Local<Object> exports) {
    ScreenCapture::Init(exports);
  }

  class SourceSuspensionChangedEventArgs : 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>("SourceSuspensionChangedEventArgs").ToLocalChecked());
        localRef->InstanceTemplate()->SetInternalFieldCount(1);





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isAudioSuspended").ToLocalChecked(), IsAudioSuspendedGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("isVideoSuspended").ToLocalChecked(), IsVideoSuspendedGetter);

        Local<Object> constructor = Nan::To<Object>(Nan::GetFunction(localRef).ToLocalChecked()).ToLocalChecked();
        Nan::SetMethod(constructor, "castFrom", CastFrom);



        Nan::Set(exports, Nan::New<String>("SourceSuspensionChangedEventArgs").ToLocalChecked(), constructor);
      }

      virtual ::Platform::Object^ GetObjectInstance() const override {
        return _instance;
      }

    private:

      SourceSuspensionChangedEventArgs(::Windows::Media::Capture::SourceSuspensionChangedEventArgs^ 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::Media::Capture::SourceSuspensionChangedEventArgs^ winRtInstance;


      if (info.Length() == 1 && OpaqueWrapper::IsOpaqueWrapper(info[0]) &&
        NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::SourceSuspensionChangedEventArgs^>(info[0])) {
        try {
          winRtInstance = (::Windows::Media::Capture::SourceSuspensionChangedEventArgs^) 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());

      SourceSuspensionChangedEventArgs *wrapperInstance = new SourceSuspensionChangedEventArgs(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::Media::Capture::SourceSuspensionChangedEventArgs^>(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::Media::Capture::SourceSuspensionChangedEventArgs^ winRtInstance;
      try {
        winRtInstance = (::Windows::Media::Capture::SourceSuspensionChangedEventArgs^) NodeRT::Utils::GetObjectInstance(info[0]);
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }

      info.GetReturnValue().Set(WrapSourceSuspensionChangedEventArgs(winRtInstance));
    }





    static void IsAudioSuspendedGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::SourceSuspensionChangedEventArgs^>(info.This())) {
        return;
      }

      SourceSuspensionChangedEventArgs *wrapper = SourceSuspensionChangedEventArgs::Unwrap<SourceSuspensionChangedEventArgs>(info.This());

      try  {
        bool result = wrapper->_instance->IsAudioSuspended;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      
    static void IsVideoSuspendedGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Media::Capture::SourceSuspensionChangedEventArgs^>(info.This())) {
        return;
      }

      SourceSuspensionChangedEventArgs *wrapper = SourceSuspensionChangedEventArgs::Unwrap<SourceSuspensionChangedEventArgs>(info.This());

      try  {
        bool result = wrapper->_instance->IsVideoSuspended;
        info.GetReturnValue().Set(Nan::New<Boolean>(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Media::Capture::SourceSuspensionChangedEventArgs^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapSourceSuspensionChangedEventArgs(::Windows::Media::Capture::SourceSuspensionChangedEventArgs^ wintRtInstance);
      friend ::Windows::Media::Capture::SourceSuspensionChangedEventArgs^ UnwrapSourceSuspensionChangedEventArgs(Local<Value> value);
  };

  Persistent<FunctionTemplate> SourceSuspensionChangedEventArgs::s_constructorTemplate;

  v8::Local<v8::Value> WrapSourceSuspensionChangedEventArgs(::Windows::Media::Capture::SourceSuspensionChangedEventArgs^ 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>(SourceSuspensionChangedEventArgs::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Media::Capture::SourceSuspensionChangedEventArgs^ UnwrapSourceSuspensionChangedEventArgs(Local<Value> value) {
     return SourceSuspensionChangedEventArgs::Unwrap<SourceSuspensionChangedEventArgs>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitSourceSuspensionChangedEventArgs(Local<Object> exports) {
    SourceSuspensionChangedEventArgs::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::Media::Capture::InitCameraCaptureUIModeEnum(target);
      NodeRT::Windows::Media::Capture::InitCameraCaptureUIPhotoFormatEnum(target);
      NodeRT::Windows::Media::Capture::InitCameraCaptureUIVideoFormatEnum(target);
      NodeRT::Windows::Media::Capture::InitCameraCaptureUIMaxVideoResolutionEnum(target);
      NodeRT::Windows::Media::Capture::InitCameraCaptureUIMaxPhotoResolutionEnum(target);
      NodeRT::Windows::Media::Capture::InitMediaCategoryEnum(target);
      NodeRT::Windows::Media::Capture::InitMediaStreamTypeEnum(target);
      NodeRT::Windows::Media::Capture::InitStreamingCaptureModeEnum(target);
      NodeRT::Windows::Media::Capture::InitVideoRotationEnum(target);
      NodeRT::Windows::Media::Capture::InitPhotoCaptureSourceEnum(target);
      NodeRT::Windows::Media::Capture::InitVideoDeviceCharacteristicEnum(target);
      NodeRT::Windows::Media::Capture::InitPowerlineFrequencyEnum(target);
      NodeRT::Windows::Media::Capture::InitMediaCaptureThermalStatusEnum(target);
      NodeRT::Windows::Media::Capture::InitMediaCaptureDeviceExclusiveControlStatusEnum(target);
      NodeRT::Windows::Media::Capture::InitKnownVideoProfileEnum(target);
      NodeRT::Windows::Media::Capture::InitMediaCaptureMemoryPreferenceEnum(target);
      NodeRT::Windows::Media::Capture::InitMediaCaptureSharingModeEnum(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastCameraOverlayLocationEnum(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastCameraOverlaySizeEnum(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastVideoEncodingBitrateModeEnum(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastVideoEncodingResolutionModeEnum(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastPlugInStateEnum(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastStreamStateEnum(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastSignInStateEnum(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastTerminationReasonEnum(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastSignInResultEnum(target);
      NodeRT::Windows::Media::Capture::InitForegroundActivationArgumentEnum(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastMicrophoneCaptureStateEnum(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastCameraCaptureStateEnum(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastExitBroadcastModeReasonEnum(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastPreviewStateEnum(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastCaptureTargetTypeEnum(target);
      NodeRT::Windows::Media::Capture::InitGameBarServicesDisplayModeEnum(target);
      NodeRT::Windows::Media::Capture::InitAppCaptureVideoEncodingBitrateModeEnum(target);
      NodeRT::Windows::Media::Capture::InitAppCaptureVideoEncodingResolutionModeEnum(target);
      NodeRT::Windows::Media::Capture::InitAppCaptureVideoEncodingFrameRateModeEnum(target);
      NodeRT::Windows::Media::Capture::InitAppCaptureHistoricalBufferLengthUnitEnum(target);
      NodeRT::Windows::Media::Capture::InitAppCaptureMicrophoneCaptureStateEnum(target);
      NodeRT::Windows::Media::Capture::InitAppCaptureRecordingStateEnum(target);
      NodeRT::Windows::Media::Capture::InitGameBarCommandEnum(target);
      NodeRT::Windows::Media::Capture::InitGameBarCommandOriginEnum(target);
      NodeRT::Windows::Media::Capture::InitGameBarTargetCapturePolicyEnum(target);
      NodeRT::Windows::Media::Capture::InitAppCapture(target);
      NodeRT::Windows::Media::Capture::InitCameraCaptureUIPhotoCaptureSettings(target);
      NodeRT::Windows::Media::Capture::InitCameraCaptureUIVideoCaptureSettings(target);
      NodeRT::Windows::Media::Capture::InitCameraCaptureUI(target);
      NodeRT::Windows::Media::Capture::InitMediaCaptureFailedEventArgs(target);
      NodeRT::Windows::Media::Capture::InitMediaCapture(target);
      NodeRT::Windows::Media::Capture::InitMediaCaptureVideoProfileMediaDescription(target);
      NodeRT::Windows::Media::Capture::InitMediaCaptureVideoProfile(target);
      NodeRT::Windows::Media::Capture::InitMediaCaptureInitializationSettings(target);
      NodeRT::Windows::Media::Capture::InitMediaCaptureSettings(target);
      NodeRT::Windows::Media::Capture::InitLowLagMediaRecording(target);
      NodeRT::Windows::Media::Capture::InitLowLagPhotoCapture(target);
      NodeRT::Windows::Media::Capture::InitLowLagPhotoSequenceCapture(target);
      NodeRT::Windows::Media::Capture::InitMediaCaptureFocusChangedEventArgs(target);
      NodeRT::Windows::Media::Capture::InitPhotoConfirmationCapturedEventArgs(target);
      NodeRT::Windows::Media::Capture::InitAdvancedPhotoCapture(target);
      NodeRT::Windows::Media::Capture::InitMediaCapturePauseResult(target);
      NodeRT::Windows::Media::Capture::InitMediaCaptureStopResult(target);
      NodeRT::Windows::Media::Capture::InitMediaCaptureDeviceExclusiveControlStatusChangedEventArgs(target);
      NodeRT::Windows::Media::Capture::InitCapturedPhoto(target);
      NodeRT::Windows::Media::Capture::InitAdvancedCapturedPhoto(target);
      NodeRT::Windows::Media::Capture::InitOptionalReferencePhotoCapturedEventArgs(target);
      NodeRT::Windows::Media::Capture::InitCapturedFrame(target);
      NodeRT::Windows::Media::Capture::InitPhotoCapturedEventArgs(target);
      NodeRT::Windows::Media::Capture::InitCapturedFrameControlValues(target);
      NodeRT::Windows::Media::Capture::InitVideoStreamConfiguration(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastGlobalSettings(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastProviderSettings(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastManager(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastBackgroundServiceSignInInfo(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastSignInStateChangedEventArgs(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastStreamReader(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastBackgroundServiceStreamInfo(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastStreamStateChangedEventArgs(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastBackgroundService(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastHeartbeatRequestedEventArgs(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastStreamAudioFrame(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastStreamVideoFrame(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastStreamVideoHeader(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastStreamAudioHeader(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastTriggerDetails(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastPlugInManager(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastPlugIn(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastPreview(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastState(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastViewerCountChangedEventArgs(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastMicrophoneCaptureStateChangedEventArgs(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastCameraCaptureStateChangedEventArgs(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastPlugInStateChangedEventArgs(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastPreviewStateChangedEventArgs(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastPreviewStreamReader(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastPreviewStreamVideoFrame(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastPreviewStreamVideoHeader(target);
      NodeRT::Windows::Media::Capture::InitAppBroadcastServices(target);
      NodeRT::Windows::Media::Capture::InitAppCaptureSettings(target);
      NodeRT::Windows::Media::Capture::InitAppCaptureAlternateShortcutKeys(target);
      NodeRT::Windows::Media::Capture::InitAppCaptureManager(target);
      NodeRT::Windows::Media::Capture::InitAppCaptureRecordOperation(target);
      NodeRT::Windows::Media::Capture::InitAppCaptureState(target);
      NodeRT::Windows::Media::Capture::InitAppCaptureMicrophoneCaptureStateChangedEventArgs(target);
      NodeRT::Windows::Media::Capture::InitAppCaptureRecordingStateChangedEventArgs(target);
      NodeRT::Windows::Media::Capture::InitAppCaptureDurationGeneratedEventArgs(target);
      NodeRT::Windows::Media::Capture::InitAppCaptureFileGeneratedEventArgs(target);
      NodeRT::Windows::Media::Capture::InitAppCaptureServices(target);
      NodeRT::Windows::Media::Capture::InitCameraOptionsUI(target);
      NodeRT::Windows::Media::Capture::InitGameBarServicesManager(target);
      NodeRT::Windows::Media::Capture::InitGameBarServicesManagerGameBarServicesCreatedEventArgs(target);
      NodeRT::Windows::Media::Capture::InitGameBarServices(target);
      NodeRT::Windows::Media::Capture::InitGameBarServicesTargetInfo(target);
      NodeRT::Windows::Media::Capture::InitGameBarServicesCommandEventArgs(target);
      NodeRT::Windows::Media::Capture::InitScreenCapture(target);
      NodeRT::Windows::Media::Capture::InitSourceSuspensionChangedEventArgs(target);


  NodeRT::Utils::RegisterNameSpace("Windows.Media.Capture", target);
}



NODE_MODULE(binding, init)