// 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 Gaming { namespace XboxLive { namespace Storage { 
  v8::Local<v8::Value> WrapGameSaveContainer(::Windows::Gaming::XboxLive::Storage::GameSaveContainer^ wintRtInstance);
  ::Windows::Gaming::XboxLive::Storage::GameSaveContainer^ UnwrapGameSaveContainer(Local<Value> value);
  
  v8::Local<v8::Value> WrapGameSaveOperationResult(::Windows::Gaming::XboxLive::Storage::GameSaveOperationResult^ wintRtInstance);
  ::Windows::Gaming::XboxLive::Storage::GameSaveOperationResult^ UnwrapGameSaveOperationResult(Local<Value> value);
  
  v8::Local<v8::Value> WrapGameSaveContainerInfoQuery(::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfoQuery^ wintRtInstance);
  ::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfoQuery^ UnwrapGameSaveContainerInfoQuery(Local<Value> value);
  
  v8::Local<v8::Value> WrapGameSaveProviderGetResult(::Windows::Gaming::XboxLive::Storage::GameSaveProviderGetResult^ wintRtInstance);
  ::Windows::Gaming::XboxLive::Storage::GameSaveProviderGetResult^ UnwrapGameSaveProviderGetResult(Local<Value> value);
  
  v8::Local<v8::Value> WrapGameSaveProvider(::Windows::Gaming::XboxLive::Storage::GameSaveProvider^ wintRtInstance);
  ::Windows::Gaming::XboxLive::Storage::GameSaveProvider^ UnwrapGameSaveProvider(Local<Value> value);
  
  v8::Local<v8::Value> WrapGameSaveBlobGetResult(::Windows::Gaming::XboxLive::Storage::GameSaveBlobGetResult^ wintRtInstance);
  ::Windows::Gaming::XboxLive::Storage::GameSaveBlobGetResult^ UnwrapGameSaveBlobGetResult(Local<Value> value);
  
  v8::Local<v8::Value> WrapGameSaveBlobInfoQuery(::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfoQuery^ wintRtInstance);
  ::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfoQuery^ UnwrapGameSaveBlobInfoQuery(Local<Value> value);
  
  v8::Local<v8::Value> WrapGameSaveContainerInfo(::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfo^ wintRtInstance);
  ::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfo^ UnwrapGameSaveContainerInfo(Local<Value> value);
  
  v8::Local<v8::Value> WrapGameSaveBlobInfo(::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfo^ wintRtInstance);
  ::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfo^ UnwrapGameSaveBlobInfo(Local<Value> value);
  
  v8::Local<v8::Value> WrapGameSaveContainerInfoGetResult(::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfoGetResult^ wintRtInstance);
  ::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfoGetResult^ UnwrapGameSaveContainerInfoGetResult(Local<Value> value);
  
  v8::Local<v8::Value> WrapGameSaveBlobInfoGetResult(::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfoGetResult^ wintRtInstance);
  ::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfoGetResult^ UnwrapGameSaveBlobInfoGetResult(Local<Value> value);
  



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

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

    Nan::Set(exports, Nan::New<String>("GameSaveErrorStatus").ToLocalChecked(), enumObject);
    Nan::Set(enumObject, Nan::New<String>("ok").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Gaming::XboxLive::Storage::GameSaveErrorStatus::Ok)));
    Nan::Set(enumObject, Nan::New<String>("abort").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Gaming::XboxLive::Storage::GameSaveErrorStatus::Abort)));
    Nan::Set(enumObject, Nan::New<String>("invalidContainerName").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Gaming::XboxLive::Storage::GameSaveErrorStatus::InvalidContainerName)));
    Nan::Set(enumObject, Nan::New<String>("noAccess").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Gaming::XboxLive::Storage::GameSaveErrorStatus::NoAccess)));
    Nan::Set(enumObject, Nan::New<String>("outOfLocalStorage").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Gaming::XboxLive::Storage::GameSaveErrorStatus::OutOfLocalStorage)));
    Nan::Set(enumObject, Nan::New<String>("userCanceled").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Gaming::XboxLive::Storage::GameSaveErrorStatus::UserCanceled)));
    Nan::Set(enumObject, Nan::New<String>("updateTooBig").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Gaming::XboxLive::Storage::GameSaveErrorStatus::UpdateTooBig)));
    Nan::Set(enumObject, Nan::New<String>("quotaExceeded").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Gaming::XboxLive::Storage::GameSaveErrorStatus::QuotaExceeded)));
    Nan::Set(enumObject, Nan::New<String>("providedBufferTooSmall").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Gaming::XboxLive::Storage::GameSaveErrorStatus::ProvidedBufferTooSmall)));
    Nan::Set(enumObject, Nan::New<String>("blobNotFound").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Gaming::XboxLive::Storage::GameSaveErrorStatus::BlobNotFound)));
    Nan::Set(enumObject, Nan::New<String>("noXboxLiveInfo").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Gaming::XboxLive::Storage::GameSaveErrorStatus::NoXboxLiveInfo)));
    Nan::Set(enumObject, Nan::New<String>("containerNotInSync").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Gaming::XboxLive::Storage::GameSaveErrorStatus::ContainerNotInSync)));
    Nan::Set(enumObject, Nan::New<String>("containerSyncFailed").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Gaming::XboxLive::Storage::GameSaveErrorStatus::ContainerSyncFailed)));
    Nan::Set(enumObject, Nan::New<String>("userHasNoXboxLiveInfo").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Gaming::XboxLive::Storage::GameSaveErrorStatus::UserHasNoXboxLiveInfo)));
    Nan::Set(enumObject, Nan::New<String>("objectExpired").ToLocalChecked(), Nan::New<Integer>(static_cast<int>(::Windows::Gaming::XboxLive::Storage::GameSaveErrorStatus::ObjectExpired)));
  }



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

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

          
            Nan::SetPrototypeMethod(localRef, "createBlobInfoQuery", CreateBlobInfoQuery);
          

          
            Nan::SetPrototypeMethod(localRef, "submitUpdatesAsync", SubmitUpdatesAsync);
            Nan::SetPrototypeMethod(localRef, "readAsync", ReadAsync);
            Nan::SetPrototypeMethod(localRef, "getAsync", GetAsync);
            Nan::SetPrototypeMethod(localRef, "submitPropertySetUpdatesAsync", SubmitPropertySetUpdatesAsync);
          


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

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



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

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

    private:

      GameSaveContainer(::Windows::Gaming::XboxLive::Storage::GameSaveContainer^ 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::Gaming::XboxLive::Storage::GameSaveContainer^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveContainer^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Gaming::XboxLive::Storage::GameSaveOperationResult^>^ op;


      if (info.Length() == 4
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IMapView<::Platform::String^, ::Windows::Storage::Streams::IBuffer^>^>(info[0]) || info[0]->IsObject())
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Platform::String^>^>(info[1]) || info[1]->IsArray())
        && info[2]->IsString())
      {
        try
        {
          ::Windows::Foundation::Collections::IMapView<::Platform::String^, ::Windows::Storage::Streams::IBuffer^>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IMapView<::Platform::String^, ::Windows::Storage::Streams::IBuffer^>^
            {
              if (value->IsObject())
              {
                return NodeRT::Collections::JsObjectToWinrtMapView<::Windows::Storage::Streams::IBuffer^>(value.As<Object>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IBuffer^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Storage::Streams::IBuffer^ {
                   return dynamic_cast<::Windows::Storage::Streams::IBuffer^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IMapView<::Platform::String^, ::Windows::Storage::Streams::IBuffer^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          ::Windows::Foundation::Collections::IIterable<::Platform::String^>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Platform::String^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Platform::String^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return (!NodeRT::Utils::IsWinRtWrapper(value));
                 },
                 [](Local<Value> value) -> ::Platform::String^ {
                   return ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Platform::String^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          Platform::String^ arg2 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[2])));
          
          op = wrapper->_instance->SubmitUpdatesAsync(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::Gaming::XboxLive::Storage::GameSaveOperationResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveContainer^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Gaming::XboxLive::Storage::GameSaveOperationResult^>^ op;


      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IMapView<::Platform::String^, ::Windows::Storage::Streams::IBuffer^>^>(info[0]) || info[0]->IsObject()))
      {
        try
        {
          ::Windows::Foundation::Collections::IMapView<::Platform::String^, ::Windows::Storage::Streams::IBuffer^>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IMapView<::Platform::String^, ::Windows::Storage::Streams::IBuffer^>^
            {
              if (value->IsObject())
              {
                return NodeRT::Collections::JsObjectToWinrtMapView<::Windows::Storage::Streams::IBuffer^>(value.As<Object>(), 
                 [](Local<Value> value) -> bool {
                   return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Storage::Streams::IBuffer^>(value);
                 },
                 [](Local<Value> value) -> ::Windows::Storage::Streams::IBuffer^ {
                   return dynamic_cast<::Windows::Storage::Streams::IBuffer^>(NodeRT::Utils::GetObjectInstance(value));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IMapView<::Platform::String^, ::Windows::Storage::Streams::IBuffer^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          op = wrapper->_instance->ReadAsync(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::Gaming::XboxLive::Storage::GameSaveOperationResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveContainer^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Gaming::XboxLive::Storage::GameSaveBlobGetResult^>^ op;


      if (info.Length() == 2
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Platform::String^>^>(info[0]) || info[0]->IsArray()))
      {
        try
        {
          ::Windows::Foundation::Collections::IIterable<::Platform::String^>^ arg0 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Platform::String^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Platform::String^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return (!NodeRT::Utils::IsWinRtWrapper(value));
                 },
                 [](Local<Value> value) -> ::Platform::String^ {
                   return ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Platform::String^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[0]);
          
          op = wrapper->_instance->GetAsync(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::Gaming::XboxLive::Storage::GameSaveBlobGetResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveContainer^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Gaming::XboxLive::Storage::GameSaveOperationResult^>^ op;


      if (info.Length() == 4
        && NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IPropertySet^>(info[0])
        && (NodeRT::Utils::IsWinRtWrapperOf<::Windows::Foundation::Collections::IIterable<::Platform::String^>^>(info[1]) || info[1]->IsArray())
        && info[2]->IsString())
      {
        try
        {
          ::Windows::Foundation::Collections::IPropertySet^ arg0 = dynamic_cast<::Windows::Foundation::Collections::IPropertySet^>(NodeRT::Utils::GetObjectInstance(info[0]));
          ::Windows::Foundation::Collections::IIterable<::Platform::String^>^ arg1 = 
            [] (v8::Local<v8::Value> value) -> ::Windows::Foundation::Collections::IIterable<::Platform::String^>^
            {
              if (value->IsArray())
              {
                return NodeRT::Collections::JsArrayToWinrtVector<::Platform::String^>(value.As<Array>(), 
                 [](Local<Value> value) -> bool {
                   return (!NodeRT::Utils::IsWinRtWrapper(value));
                 },
                 [](Local<Value> value) -> ::Platform::String^ {
                   return ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), value)));
                 }
                );
              }
              else
              {
                return dynamic_cast<::Windows::Foundation::Collections::IIterable<::Platform::String^>^>(NodeRT::Utils::GetObjectInstance(value));
              }
            } (info[1]);
          Platform::String^ arg2 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[2])));
          
          op = wrapper->_instance->SubmitPropertySetUpdatesAsync(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::Gaming::XboxLive::Storage::GameSaveOperationResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveContainer^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          ::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfoQuery^ result;
          result = wrapper->_instance->CreateBlobInfoQuery(arg0);
          info.GetReturnValue().Set(WrapGameSaveBlobInfoQuery(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 NameGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveContainer^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveContainer^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Gaming::XboxLive::Storage::GameSaveProvider^ result = wrapper->_instance->Provider;
        info.GetReturnValue().Set(WrapGameSaveProvider(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Gaming::XboxLive::Storage::GameSaveContainer^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapGameSaveContainer(::Windows::Gaming::XboxLive::Storage::GameSaveContainer^ wintRtInstance);
      friend ::Windows::Gaming::XboxLive::Storage::GameSaveContainer^ UnwrapGameSaveContainer(Local<Value> value);
  };

  Persistent<FunctionTemplate> GameSaveContainer::s_constructorTemplate;

  v8::Local<v8::Value> WrapGameSaveContainer(::Windows::Gaming::XboxLive::Storage::GameSaveContainer^ 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>(GameSaveContainer::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Gaming::XboxLive::Storage::GameSaveContainer^ UnwrapGameSaveContainer(Local<Value> value) {
     return GameSaveContainer::Unwrap<GameSaveContainer>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitGameSaveContainer(Local<Object> exports) {
    GameSaveContainer::Init(exports);
  }

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





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

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

    private:

      GameSaveOperationResult(::Windows::Gaming::XboxLive::Storage::GameSaveOperationResult^ 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::Gaming::XboxLive::Storage::GameSaveOperationResult^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveOperationResult^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Gaming::XboxLive::Storage::GameSaveErrorStatus 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::Gaming::XboxLive::Storage::GameSaveOperationResult^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapGameSaveOperationResult(::Windows::Gaming::XboxLive::Storage::GameSaveOperationResult^ wintRtInstance);
      friend ::Windows::Gaming::XboxLive::Storage::GameSaveOperationResult^ UnwrapGameSaveOperationResult(Local<Value> value);
  };

  Persistent<FunctionTemplate> GameSaveOperationResult::s_constructorTemplate;

  v8::Local<v8::Value> WrapGameSaveOperationResult(::Windows::Gaming::XboxLive::Storage::GameSaveOperationResult^ 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>(GameSaveOperationResult::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Gaming::XboxLive::Storage::GameSaveOperationResult^ UnwrapGameSaveOperationResult(Local<Value> value) {
     return GameSaveOperationResult::Unwrap<GameSaveOperationResult>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitGameSaveOperationResult(Local<Object> exports) {
    GameSaveOperationResult::Init(exports);
  }

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

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


          
            Nan::SetPrototypeMethod(localRef, "getContainerInfoAsync", GetContainerInfoAsync);
            Nan::SetPrototypeMethod(localRef, "getItemCountAsync", GetItemCountAsync);
          



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



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

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

    private:

      GameSaveContainerInfoQuery(::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfoQuery^ 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::Gaming::XboxLive::Storage::GameSaveContainerInfoQuery^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfoQuery^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfoGetResult^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->GetContainerInfoAsync();
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && info[0]->IsUint32()
        && info[1]->IsUint32())
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          unsigned int arg1 = static_cast<unsigned int>(Nan::To<uint32_t>(info[1]).FromMaybe(0));
          
          op = wrapper->_instance->GetContainerInfoAsync(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::Gaming::XboxLive::Storage::GameSaveContainerInfoGetResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfoQuery^>(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;
      }

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

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


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->GetItemCountAsync();
        }
        catch (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);
          });
        }
      });
    }






    private:
      ::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfoQuery^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapGameSaveContainerInfoQuery(::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfoQuery^ wintRtInstance);
      friend ::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfoQuery^ UnwrapGameSaveContainerInfoQuery(Local<Value> value);
  };

  Persistent<FunctionTemplate> GameSaveContainerInfoQuery::s_constructorTemplate;

  v8::Local<v8::Value> WrapGameSaveContainerInfoQuery(::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfoQuery^ 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>(GameSaveContainerInfoQuery::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfoQuery^ UnwrapGameSaveContainerInfoQuery(Local<Value> value) {
     return GameSaveContainerInfoQuery::Unwrap<GameSaveContainerInfoQuery>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitGameSaveContainerInfoQuery(Local<Object> exports) {
    GameSaveContainerInfoQuery::Init(exports);
  }

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





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

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



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

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

    private:

      GameSaveProviderGetResult(::Windows::Gaming::XboxLive::Storage::GameSaveProviderGetResult^ 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::Gaming::XboxLive::Storage::GameSaveProviderGetResult^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveProviderGetResult^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveProviderGetResult^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Gaming::XboxLive::Storage::GameSaveProvider^ result = wrapper->_instance->Value;
        info.GetReturnValue().Set(WrapGameSaveProvider(result));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Gaming::XboxLive::Storage::GameSaveProviderGetResult^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapGameSaveProviderGetResult(::Windows::Gaming::XboxLive::Storage::GameSaveProviderGetResult^ wintRtInstance);
      friend ::Windows::Gaming::XboxLive::Storage::GameSaveProviderGetResult^ UnwrapGameSaveProviderGetResult(Local<Value> value);
  };

  Persistent<FunctionTemplate> GameSaveProviderGetResult::s_constructorTemplate;

  v8::Local<v8::Value> WrapGameSaveProviderGetResult(::Windows::Gaming::XboxLive::Storage::GameSaveProviderGetResult^ 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>(GameSaveProviderGetResult::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Gaming::XboxLive::Storage::GameSaveProviderGetResult^ UnwrapGameSaveProviderGetResult(Local<Value> value) {
     return GameSaveProviderGetResult::Unwrap<GameSaveProviderGetResult>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitGameSaveProviderGetResult(Local<Object> exports) {
    GameSaveProviderGetResult::Init(exports);
  }

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

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

          
            Nan::SetPrototypeMethod(localRef, "createContainer", CreateContainer);
            Nan::SetPrototypeMethod(localRef, "createContainerInfoQuery", CreateContainerInfoQuery);
          

          
            Nan::SetPrototypeMethod(localRef, "deleteContainerAsync", DeleteContainerAsync);
            Nan::SetPrototypeMethod(localRef, "getRemainingBytesInQuotaAsync", GetRemainingBytesInQuotaAsync);
          


          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("containersChangedSinceLastSync").ToLocalChecked(), ContainersChangedSinceLastSyncGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("user").ToLocalChecked(), UserGetter);

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

        func = Nan::GetFunction(Nan::New<FunctionTemplate>(GetForUserAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("getForUserAsync").ToLocalChecked(), func);
        func = Nan::GetFunction(Nan::New<FunctionTemplate>(GetSyncOnDemandForUserAsync)).ToLocalChecked();
        Nan::Set(constructor, Nan::New<String>("getSyncOnDemandForUserAsync").ToLocalChecked(), func);


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

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

    private:

      GameSaveProvider(::Windows::Gaming::XboxLive::Storage::GameSaveProvider^ 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::Gaming::XboxLive::Storage::GameSaveProvider^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveProvider^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Gaming::XboxLive::Storage::GameSaveOperationResult^>^ op;


      if (info.Length() == 2
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          op = wrapper->_instance->DeleteContainerAsync(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::Gaming::XboxLive::Storage::GameSaveOperationResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveProvider^>(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;
      }

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

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


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->GetRemainingBytesInQuotaAsync();
        }
        catch (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<__int64> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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


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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          ::Windows::Gaming::XboxLive::Storage::GameSaveContainer^ result;
          result = wrapper->_instance->CreateContainer(arg0);
          info.GetReturnValue().Set(WrapGameSaveContainer(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 CreateContainerInfoQuery(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveProvider^>(info.This())) {
        return;
      }

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

      if (info.Length() == 0)
      {
        try
        {
          ::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfoQuery^ result;
          result = wrapper->_instance->CreateContainerInfoQuery();
          info.GetReturnValue().Set(WrapGameSaveContainerInfoQuery(result));
          return;
        } catch (Platform::Exception ^exception) {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 1
        && info[0]->IsString())
      {
        try
        {
          Platform::String^ arg0 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[0])));
          
          ::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfoQuery^ result;
          result = wrapper->_instance->CreateContainerInfoQuery(arg0);
          info.GetReturnValue().Set(WrapGameSaveContainerInfoQuery(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 GetForUserAsync(Nan::NAN_METHOD_ARGS_TYPE info) {
      HandleScope scope;

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Gaming::XboxLive::Storage::GameSaveProviderGetResult^>^ op;


      if (info.Length() == 3
          && NodeRT::Utils::IsWinRtWrapperOf<::Windows::System::User^>(info[0])
          && info[1]->IsString())
      {
        try
        {
          ::Windows::System::User^ arg0 = dynamic_cast<::Windows::System::User^>(NodeRT::Utils::GetObjectInstance(info[0]));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
            
          op = ::Windows::Gaming::XboxLive::Storage::GameSaveProvider::GetForUserAsync(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::Gaming::XboxLive::Storage::GameSaveProviderGetResult^> t)
      {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Gaming::XboxLive::Storage::GameSaveProviderGetResult^>^ op;


      if (info.Length() == 3
          && NodeRT::Utils::IsWinRtWrapperOf<::Windows::System::User^>(info[0])
          && info[1]->IsString())
      {
        try
        {
          ::Windows::System::User^ arg0 = dynamic_cast<::Windows::System::User^>(NodeRT::Utils::GetObjectInstance(info[0]));
          Platform::String^ arg1 = ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value(v8::Isolate::GetCurrent(), info[1])));
            
          op = ::Windows::Gaming::XboxLive::Storage::GameSaveProvider::GetSyncOnDemandForUserAsync(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::Gaming::XboxLive::Storage::GameSaveProviderGetResult^> t)
      {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


            Local<Value> error;
            Local<Value> arg1;
            {
              TryCatch tryCatch;
              arg1 = WrapGameSaveProviderGetResult(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 ContainersChangedSinceLastSyncGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveProvider^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveProvider^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Gaming::XboxLive::Storage::GameSaveProvider^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapGameSaveProvider(::Windows::Gaming::XboxLive::Storage::GameSaveProvider^ wintRtInstance);
      friend ::Windows::Gaming::XboxLive::Storage::GameSaveProvider^ UnwrapGameSaveProvider(Local<Value> value);
  };

  Persistent<FunctionTemplate> GameSaveProvider::s_constructorTemplate;

  v8::Local<v8::Value> WrapGameSaveProvider(::Windows::Gaming::XboxLive::Storage::GameSaveProvider^ 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>(GameSaveProvider::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Gaming::XboxLive::Storage::GameSaveProvider^ UnwrapGameSaveProvider(Local<Value> value) {
     return GameSaveProvider::Unwrap<GameSaveProvider>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitGameSaveProvider(Local<Object> exports) {
    GameSaveProvider::Init(exports);
  }

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





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

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



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

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

    private:

      GameSaveBlobGetResult(::Windows::Gaming::XboxLive::Storage::GameSaveBlobGetResult^ 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::Gaming::XboxLive::Storage::GameSaveBlobGetResult^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveBlobGetResult^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveBlobGetResult^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IMapView<::Platform::String^, ::Windows::Storage::Streams::IBuffer^>^ result = wrapper->_instance->Value;
        info.GetReturnValue().Set(NodeRT::Collections::MapViewWrapper<::Platform::String^,::Windows::Storage::Streams::IBuffer^>::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::Storage::Streams::IBuffer^ val) -> Local<Value> {
              return NodeRT::Utils::CreateExternalWinRTObject("Windows.Storage.Streams", "IBuffer", val);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Gaming::XboxLive::Storage::GameSaveBlobGetResult^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapGameSaveBlobGetResult(::Windows::Gaming::XboxLive::Storage::GameSaveBlobGetResult^ wintRtInstance);
      friend ::Windows::Gaming::XboxLive::Storage::GameSaveBlobGetResult^ UnwrapGameSaveBlobGetResult(Local<Value> value);
  };

  Persistent<FunctionTemplate> GameSaveBlobGetResult::s_constructorTemplate;

  v8::Local<v8::Value> WrapGameSaveBlobGetResult(::Windows::Gaming::XboxLive::Storage::GameSaveBlobGetResult^ 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>(GameSaveBlobGetResult::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Gaming::XboxLive::Storage::GameSaveBlobGetResult^ UnwrapGameSaveBlobGetResult(Local<Value> value) {
     return GameSaveBlobGetResult::Unwrap<GameSaveBlobGetResult>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitGameSaveBlobGetResult(Local<Object> exports) {
    GameSaveBlobGetResult::Init(exports);
  }

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

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


          
            Nan::SetPrototypeMethod(localRef, "getBlobInfoAsync", GetBlobInfoAsync);
            Nan::SetPrototypeMethod(localRef, "getItemCountAsync", GetItemCountAsync);
          



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



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

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

    private:

      GameSaveBlobInfoQuery(::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfoQuery^ 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::Gaming::XboxLive::Storage::GameSaveBlobInfoQuery^ winRtInstance;


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

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

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfoQuery^>(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;
      }

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

      ::Windows::Foundation::IAsyncOperation<::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfoGetResult^>^ op;


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->GetBlobInfoAsync();
        }
        catch (Platform::Exception ^exception)
        {
          NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
          return;
        }
      }
      else if (info.Length() == 3
        && info[0]->IsUint32()
        && info[1]->IsUint32())
      {
        try
        {
          unsigned int arg0 = static_cast<unsigned int>(Nan::To<uint32_t>(info[0]).FromMaybe(0));
          unsigned int arg1 = static_cast<unsigned int>(Nan::To<uint32_t>(info[1]).FromMaybe(0));
          
          op = wrapper->_instance->GetBlobInfoAsync(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::Gaming::XboxLive::Storage::GameSaveBlobInfoGetResult^> t) {
        try {
          auto result = t.get();
          NodeUtils::Async::RunCallbackOnMain(asyncToken, [result](NodeUtils::InvokeCallbackDelegate invokeCallback) {


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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfoQuery^>(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;
      }

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

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


      if (info.Length() == 1)
      {
        try
        {
          op = wrapper->_instance->GetItemCountAsync();
        }
        catch (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);
          });
        }
      });
    }






    private:
      ::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfoQuery^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapGameSaveBlobInfoQuery(::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfoQuery^ wintRtInstance);
      friend ::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfoQuery^ UnwrapGameSaveBlobInfoQuery(Local<Value> value);
  };

  Persistent<FunctionTemplate> GameSaveBlobInfoQuery::s_constructorTemplate;

  v8::Local<v8::Value> WrapGameSaveBlobInfoQuery(::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfoQuery^ 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>(GameSaveBlobInfoQuery::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfoQuery^ UnwrapGameSaveBlobInfoQuery(Local<Value> value) {
     return GameSaveBlobInfoQuery::Unwrap<GameSaveBlobInfoQuery>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitGameSaveBlobInfoQuery(Local<Object> exports) {
    GameSaveBlobInfoQuery::Init(exports);
  }

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





          
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("displayName").ToLocalChecked(), DisplayNameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("lastModifiedTime").ToLocalChecked(), LastModifiedTimeGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("name").ToLocalChecked(), NameGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("needsSync").ToLocalChecked(), NeedsSyncGetter);
            Nan::SetAccessor(localRef->PrototypeTemplate(), Nan::New<String>("totalSize").ToLocalChecked(), TotalSizeGetter);

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



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

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

    private:

      GameSaveContainerInfo(::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfo^ 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::Gaming::XboxLive::Storage::GameSaveContainerInfo^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfo^>(info.This())) {
        return;
      }

      GameSaveContainerInfo *wrapper = GameSaveContainerInfo::Unwrap<GameSaveContainerInfo>(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 LastModifiedTimeGetter(Local<String> property, const Nan::PropertyCallbackInfo<v8::Value> &info) {
      HandleScope scope;

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfo^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfo^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfo^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfo^>(info.This())) {
        return;
      }

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

      try  {
        unsigned __int64 result = wrapper->_instance->TotalSize;
        info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(result)));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfo^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapGameSaveContainerInfo(::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfo^ wintRtInstance);
      friend ::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfo^ UnwrapGameSaveContainerInfo(Local<Value> value);
  };

  Persistent<FunctionTemplate> GameSaveContainerInfo::s_constructorTemplate;

  v8::Local<v8::Value> WrapGameSaveContainerInfo(::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfo^ 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>(GameSaveContainerInfo::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfo^ UnwrapGameSaveContainerInfo(Local<Value> value) {
     return GameSaveContainerInfo::Unwrap<GameSaveContainerInfo>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitGameSaveContainerInfo(Local<Object> exports) {
    GameSaveContainerInfo::Init(exports);
  }

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





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

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



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

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

    private:

      GameSaveBlobInfo(::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfo^ 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::Gaming::XboxLive::Storage::GameSaveBlobInfo^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfo^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfo^>(info.This())) {
        return;
      }

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

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


    private:
      ::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfo^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapGameSaveBlobInfo(::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfo^ wintRtInstance);
      friend ::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfo^ UnwrapGameSaveBlobInfo(Local<Value> value);
  };

  Persistent<FunctionTemplate> GameSaveBlobInfo::s_constructorTemplate;

  v8::Local<v8::Value> WrapGameSaveBlobInfo(::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfo^ 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>(GameSaveBlobInfo::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfo^ UnwrapGameSaveBlobInfo(Local<Value> value) {
     return GameSaveBlobInfo::Unwrap<GameSaveBlobInfo>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitGameSaveBlobInfo(Local<Object> exports) {
    GameSaveBlobInfo::Init(exports);
  }

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





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

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



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

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

    private:

      GameSaveContainerInfoGetResult(::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfoGetResult^ 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::Gaming::XboxLive::Storage::GameSaveContainerInfoGetResult^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfoGetResult^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfoGetResult^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfo^>^ result = wrapper->_instance->Value;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfo^>::CreateVectorViewWrapper(result, 
            [](::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfo^ val) -> Local<Value> {
              return WrapGameSaveContainerInfo(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfo^>(value);
            },
            [](Local<Value> value) -> ::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfo^ {
              return UnwrapGameSaveContainerInfo(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfoGetResult^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapGameSaveContainerInfoGetResult(::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfoGetResult^ wintRtInstance);
      friend ::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfoGetResult^ UnwrapGameSaveContainerInfoGetResult(Local<Value> value);
  };

  Persistent<FunctionTemplate> GameSaveContainerInfoGetResult::s_constructorTemplate;

  v8::Local<v8::Value> WrapGameSaveContainerInfoGetResult(::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfoGetResult^ 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>(GameSaveContainerInfoGetResult::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Gaming::XboxLive::Storage::GameSaveContainerInfoGetResult^ UnwrapGameSaveContainerInfoGetResult(Local<Value> value) {
     return GameSaveContainerInfoGetResult::Unwrap<GameSaveContainerInfoGetResult>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitGameSaveContainerInfoGetResult(Local<Object> exports) {
    GameSaveContainerInfoGetResult::Init(exports);
  }

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





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

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



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

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

    private:

      GameSaveBlobInfoGetResult(::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfoGetResult^ 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::Gaming::XboxLive::Storage::GameSaveBlobInfoGetResult^ winRtInstance;


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

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

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





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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfoGetResult^>(info.This())) {
        return;
      }

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

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

      if (!NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfoGetResult^>(info.This())) {
        return;
      }

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

      try  {
        ::Windows::Foundation::Collections::IVectorView<::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfo^>^ result = wrapper->_instance->Value;
        info.GetReturnValue().Set(NodeRT::Collections::VectorViewWrapper<::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfo^>::CreateVectorViewWrapper(result, 
            [](::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfo^ val) -> Local<Value> {
              return WrapGameSaveBlobInfo(val);
            },
            [](Local<Value> value) -> bool {
              return NodeRT::Utils::IsWinRtWrapperOf<::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfo^>(value);
            },
            [](Local<Value> value) -> ::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfo^ {
              return UnwrapGameSaveBlobInfo(value);
            }
          ));
        return;
      } catch (Platform::Exception ^exception) {
        NodeRT::Utils::ThrowWinRtExceptionInJs(exception);
        return;
      }
    }
      


    private:
      ::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfoGetResult^ _instance;
      static Persistent<FunctionTemplate> s_constructorTemplate;

      friend v8::Local<v8::Value> WrapGameSaveBlobInfoGetResult(::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfoGetResult^ wintRtInstance);
      friend ::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfoGetResult^ UnwrapGameSaveBlobInfoGetResult(Local<Value> value);
  };

  Persistent<FunctionTemplate> GameSaveBlobInfoGetResult::s_constructorTemplate;

  v8::Local<v8::Value> WrapGameSaveBlobInfoGetResult(::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfoGetResult^ 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>(GameSaveBlobInfoGetResult::s_constructorTemplate);
    return scope.Escape(Nan::NewInstance(Nan::GetFunction(localRef).ToLocalChecked(),_countof(args), args).ToLocalChecked());
  }

  ::Windows::Gaming::XboxLive::Storage::GameSaveBlobInfoGetResult^ UnwrapGameSaveBlobInfoGetResult(Local<Value> value) {
     return GameSaveBlobInfoGetResult::Unwrap<GameSaveBlobInfoGetResult>(Nan::To<Object>(value).ToLocalChecked())->_instance;
  }

  void InitGameSaveBlobInfoGetResult(Local<Object> exports) {
    GameSaveBlobInfoGetResult::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::Gaming::XboxLive::Storage::InitGameSaveErrorStatusEnum(target);
      NodeRT::Windows::Gaming::XboxLive::Storage::InitGameSaveContainer(target);
      NodeRT::Windows::Gaming::XboxLive::Storage::InitGameSaveOperationResult(target);
      NodeRT::Windows::Gaming::XboxLive::Storage::InitGameSaveContainerInfoQuery(target);
      NodeRT::Windows::Gaming::XboxLive::Storage::InitGameSaveProviderGetResult(target);
      NodeRT::Windows::Gaming::XboxLive::Storage::InitGameSaveProvider(target);
      NodeRT::Windows::Gaming::XboxLive::Storage::InitGameSaveBlobGetResult(target);
      NodeRT::Windows::Gaming::XboxLive::Storage::InitGameSaveBlobInfoQuery(target);
      NodeRT::Windows::Gaming::XboxLive::Storage::InitGameSaveContainerInfo(target);
      NodeRT::Windows::Gaming::XboxLive::Storage::InitGameSaveBlobInfo(target);
      NodeRT::Windows::Gaming::XboxLive::Storage::InitGameSaveContainerInfoGetResult(target);
      NodeRT::Windows::Gaming::XboxLive::Storage::InitGameSaveBlobInfoGetResult(target);


  NodeRT::Utils::RegisterNameSpace("Windows.Gaming.XboxLive.Storage", target);
}



NODE_MODULE(binding, init)