/**
 * This code is auto-generated; unless you know what you're doing, do not modify!
 **/

#ifndef GITSUBMODULE_H
#define GITSUBMODULE_H

#include 
#include 
#include 

#include "git2.h"

using namespace node;
using namespace v8;

class GitSubmodule : public ObjectWrap {
  public:

    static Persistent constructor_template;
    static void Initialize (Handle target);

    git_submodule *GetValue();

    static Handle New(void *raw);

  private:
    GitSubmodule(git_submodule *raw);
    ~GitSubmodule();

    static Handle New(const Arguments& args);


    static Handle AddFinalize(const Arguments& args);
    static void AddFinalizeWork(uv_work_t* req);
    static void AddFinalizeAfterWork(uv_work_t* req);

    struct AddFinalizeBaton {
      uv_work_t request;
      int error_code;
      const git_error* error;
      Persistent submoduleReference;
      git_submodule * submodule;
      Persistent callback;
    };
    static Handle AddToIndex(const Arguments& args);
    static void AddToIndexWork(uv_work_t* req);
    static void AddToIndexAfterWork(uv_work_t* req);

    struct AddToIndexBaton {
      uv_work_t request;
      int error_code;
      const git_error* error;
      Persistent submoduleReference;
      git_submodule * submodule;
      Persistent write_indexReference;
      int write_index;
      Persistent callback;
    };
    static Handle Save(const Arguments& args);
    static void SaveWork(uv_work_t* req);
    static void SaveAfterWork(uv_work_t* req);

    struct SaveBaton {
      uv_work_t request;
      int error_code;
      const git_error* error;
      Persistent submoduleReference;
      git_submodule * submodule;
      Persistent callback;
    };
    static Handle Name(const Arguments& args);
    static Handle Path(const Arguments& args);
    static Handle Url(const Arguments& args);
    static Handle SetUrl(const Arguments& args);
    static Handle IndexId(const Arguments& args);
    static Handle HeadId(const Arguments& args);
    static Handle Init(const Arguments& args);
    static void InitWork(uv_work_t* req);
    static void InitAfterWork(uv_work_t* req);

    struct InitBaton {
      uv_work_t request;
      int error_code;
      const git_error* error;
      Persistent submoduleReference;
      git_submodule * submodule;
      Persistent overwriteReference;
      int overwrite;
      Persistent callback;
    };
    static Handle Sync(const Arguments& args);
    static void SyncWork(uv_work_t* req);
    static void SyncAfterWork(uv_work_t* req);

    struct SyncBaton {
      uv_work_t request;
      int error_code;
      const git_error* error;
      Persistent submoduleReference;
      git_submodule * submodule;
      Persistent callback;
    };
    static Handle Open(const Arguments& args);
    static void OpenWork(uv_work_t* req);
    static void OpenAfterWork(uv_work_t* req);

    struct OpenBaton {
      uv_work_t request;
      int error_code;
      const git_error* error;
      git_repository * repo;
      Persistent submoduleReference;
      git_submodule * submodule;
      Persistent callback;
    };
    static Handle Reload(const Arguments& args);
    static void ReloadWork(uv_work_t* req);
    static void ReloadAfterWork(uv_work_t* req);

    struct ReloadBaton {
      uv_work_t request;
      int error_code;
      const git_error* error;
      Persistent submoduleReference;
      git_submodule * submodule;
      Persistent callback;
    };
    static Handle Status(const Arguments& args);
    static void StatusWork(uv_work_t* req);
    static void StatusAfterWork(uv_work_t* req);

    struct StatusBaton {
      uv_work_t request;
      int error_code;
      const git_error* error;
      Persistent statusReference;
      unsigned int * status;
      Persistent submoduleReference;
      git_submodule * submodule;
      Persistent callback;
    };
    git_submodule *raw;
};

#endif