Added java bindings for Android

186 files changed, 9280 insertions, 0 deletions

diff --git a/src/java/JavaConnectionLogger.cpp b/src/java/JavaConnectionLogger.cpp
new file mode 100644
index 00000000..a0e4d1a9
--- /dev/null
+++ b/src/java/JavaConnectionLogger.cpp
@@ -0,0 +1,19 @@
+#include "JavaConnectionLogger.h"
+
+#include "TypesUtils.h"
+
+using namespace mailcore;
+
+JavaConnectionLogger::JavaConnectionLogger(JNIEnv * env, jobject logger)
+{
+    mLogger = logger;
+    mEnv = env;
+}
+
+void JavaConnectionLogger::log(void * sender, ConnectionLogType logType, Data * buffer)
+{
+    JNIEnv * env = mEnv;
+    jclass cls = mEnv->GetObjectClass(mLogger);
+    jmethodID mid = mEnv->GetMethodID(cls, "log", "(JI[B)V");
+    mEnv->CallVoidMethod(mLogger, mid, (jlong) sender, (jint) logType, MC_TO_JAVA(buffer));
+}
diff --git a/src/java/JavaConnectionLogger.h b/src/java/JavaConnectionLogger.h
new file mode 100644
index 00000000..eb74b853
--- /dev/null
+++ b/src/java/JavaConnectionLogger.h
@@ -0,0 +1,24 @@
+#ifndef MAILCORE_JAVA_CONNECTION_LOGGER_H
+
+#define MAILCORE_JAVA_CONNECTION_LOGGER_H
+
+#include <jni.h>
+#include "MCConnectionLogger.h"
+#include "MCBaseTypes.h"
+
+namespace mailcore {
+
+class JavaConnectionLogger : public Object, public ConnectionLogger {
+public:
+    JavaConnectionLogger(JNIEnv * env, jobject logger);
+    
+    virtual void log(void * sender, ConnectionLogType logType, Data * buffer);
+    
+private:
+    jobject mLogger;
+    JNIEnv * mEnv;
+};
+
+}
+
+#endif
diff --git a/src/java/JavaHTMLRendererIMAPCallback.cpp b/src/java/JavaHTMLRendererIMAPCallback.cpp
new file mode 100644
index 00000000..11378450
--- /dev/null
+++ b/src/java/JavaHTMLRendererIMAPCallback.cpp
@@ -0,0 +1,35 @@
+#include "JavaHTMLRendererIMAPCallback.h"
+
+#include "TypesUtils.h"
+
+using namespace mailcore;
+
+JavaHTMLRendererIMAPCallback::JavaHTMLRendererIMAPCallback(JNIEnv * env, jobject callback)
+{
+    mCallback = callback;
+    mEnv = env;
+}
+
+Data * JavaHTMLRendererIMAPCallback::dataForIMAPPart(String * folder, IMAPPart * part)
+{
+    JNIEnv * env = mEnv;
+    jclass cls = mEnv->GetObjectClass(mCallback);
+    jmethodID mid = mEnv->GetMethodID(cls, "dataForIMAPPart", "(Ljava/lang/String;Lcom/libmailcore/IMAPPart;)[B");
+    return MC_FROM_JAVA(Data, mEnv->CallObjectMethod(mCallback, mid, MC_TO_JAVA(folder), MC_TO_JAVA(part)));
+}
+
+void JavaHTMLRendererIMAPCallback::prefetchAttachmentIMAPPart(String * folder, IMAPPart * part)
+{
+    JNIEnv * env = mEnv;
+    jclass cls = mEnv->GetObjectClass(mCallback);
+    jmethodID mid = mEnv->GetMethodID(cls, "prefetchAttachmentIMAPPart", "(Ljava/lang/String;Lcom/libmailcore/IMAPPart;)V");
+    mEnv->CallVoidMethod(mCallback, mid, MC_TO_JAVA(folder), MC_TO_JAVA(part));
+}
+
+void JavaHTMLRendererIMAPCallback::prefetchImageIMAPPart(String * folder, IMAPPart * part)
+{
+    JNIEnv * env = mEnv;
+    jclass cls = mEnv->GetObjectClass(mCallback);
+    jmethodID mid = mEnv->GetMethodID(cls, "prefetchImageIMAPPart", "(Ljava/lang/String;Lcom/libmailcore/IMAPPart;)V");
+    mEnv->CallVoidMethod(mCallback, mid, MC_TO_JAVA(folder), MC_TO_JAVA(part));
+}
diff --git a/src/java/JavaHTMLRendererIMAPCallback.h b/src/java/JavaHTMLRendererIMAPCallback.h
new file mode 100644
index 00000000..7179db91
--- /dev/null
+++ b/src/java/JavaHTMLRendererIMAPCallback.h
@@ -0,0 +1,27 @@
+#ifndef MAILCORE_JAVA_HTML_RENDERER_IMAP_CALLBACK_H
+
+#define MAILCORE_JAVA_HTML_RENDERER_IMAP_CALLBACK_H
+
+#include <jni.h>
+
+#include "MCBaseTypes.h"
+#include "MCHTMLRendererCallback.h"
+
+namespace mailcore {
+
+class JavaHTMLRendererIMAPCallback : public Object, public HTMLRendererIMAPCallback {
+public:
+    JavaHTMLRendererIMAPCallback(JNIEnv * env, jobject callback);
+    
+    virtual Data * dataForIMAPPart(String * folder, IMAPPart * part);
+    virtual void prefetchAttachmentIMAPPart(String * folder, IMAPPart * part);
+    virtual void prefetchImageIMAPPart(String * folder, IMAPPart * part);
+    
+private:
+    jobject mCallback;
+    JNIEnv * mEnv;
+};
+
+}
+
+#endif
diff --git a/src/java/JavaHTMLRendererTemplateCallback.cpp b/src/java/JavaHTMLRendererTemplateCallback.cpp
new file mode 100644
index 00000000..cd18855a
--- /dev/null
+++ b/src/java/JavaHTMLRendererTemplateCallback.cpp
@@ -0,0 +1,123 @@
+#include "JavaHTMLRendererTemplateCallback.h"
+
+#include "TypesUtils.h"
+
+using namespace mailcore;
+
+bool JavaHTMLRendererTemplateCallback::canPreviewPart(AbstractPart * part)
+{
+    JNIEnv * env = mEnv;
+    jclass cls = mEnv->GetObjectClass(mCallback);
+    jmethodID mid = mEnv->GetMethodID(cls, "canPreviewPart", "(Lcom/libmailcore/AbstractPart;)Z");
+    return (bool) mEnv->CallBooleanMethod(mCallback, mid, MC_TO_JAVA(part));
+}
+    
+bool JavaHTMLRendererTemplateCallback::shouldShowPart(AbstractPart * part)
+{
+    JNIEnv * env = mEnv;
+    jclass cls = mEnv->GetObjectClass(mCallback);
+    jmethodID mid = mEnv->GetMethodID(cls, "shouldShowPart", "(Lcom/libmailcore/AbstractPart;)Z");
+    return (bool) mEnv->CallBooleanMethod(mCallback, mid, MC_TO_JAVA(part));
+}
+    
+HashMap * JavaHTMLRendererTemplateCallback::templateValuesForHeader(MessageHeader * header)
+{
+    JNIEnv * env = mEnv;
+    jclass cls = mEnv->GetObjectClass(mCallback);
+    jmethodID mid = mEnv->GetMethodID(cls, "templateValuesForHeader", "(Lcom/libmailcore/MessageHeader;)Ljava/util/Map;");
+    return MC_FROM_JAVA(HashMap, mEnv->CallObjectMethod(mCallback, mid, MC_TO_JAVA(header)));
+}
+    
+HashMap * JavaHTMLRendererTemplateCallback::templateValuesForPart(AbstractPart * part)
+{
+    JNIEnv * env = mEnv;
+    jclass cls = mEnv->GetObjectClass(mCallback);
+    jmethodID mid = mEnv->GetMethodID(cls, "templateValuesForPart", "(Lcom/libmailcore/AbstractPart;)Ljava/util/Map;");
+    return MC_FROM_JAVA(HashMap, mEnv->CallObjectMethod(mCallback, mid, MC_TO_JAVA(part)));
+}
+    
+String * JavaHTMLRendererTemplateCallback::templateForMainHeader(MessageHeader * header)
+{
+    JNIEnv * env = mEnv;
+    jclass cls = mEnv->GetObjectClass(mCallback);
+    jmethodID mid = mEnv->GetMethodID(cls, "templateForMainHeader", "(Lcom/libmailcore/MessageHeader;)Ljava/lang/String;");
+    return MC_FROM_JAVA(String, mEnv->CallObjectMethod(mCallback, mid, MC_TO_JAVA(header)));
+}
+    
+String * JavaHTMLRendererTemplateCallback::templateForImage(AbstractPart * part)
+{
+    JNIEnv * env = mEnv;
+    jclass cls = mEnv->GetObjectClass(mCallback);
+    jmethodID mid = mEnv->GetMethodID(cls, "templateForImage", "(Lcom/libmailcore/AbstractPart;)Ljava/lang/String;");
+    return MC_FROM_JAVA(String, mEnv->CallObjectMethod(mCallback, mid, MC_TO_JAVA(part)));
+}
+    
+String * JavaHTMLRendererTemplateCallback::templateForAttachment(AbstractPart * part)
+{
+    JNIEnv * env = mEnv;
+    jclass cls = mEnv->GetObjectClass(mCallback);
+    jmethodID mid = mEnv->GetMethodID(cls, "templateForAttachment", "(Lcom/libmailcore/AbstractPart;)Ljava/lang/String;");
+    return MC_FROM_JAVA(String, mEnv->CallObjectMethod(mCallback, mid, MC_TO_JAVA(part)));
+}
+    
+String * JavaHTMLRendererTemplateCallback::templateForMessage(AbstractMessage * message)
+{
+    JNIEnv * env = mEnv;
+    jclass cls = mEnv->GetObjectClass(mCallback);
+    jmethodID mid = mEnv->GetMethodID(cls, "templateForAttachment", "(Lcom/libmailcore/AbstractMessage;)Ljava/lang/String;");
+    return MC_FROM_JAVA(String, mEnv->CallObjectMethod(mCallback, mid, MC_TO_JAVA(message)));
+}
+    
+String * JavaHTMLRendererTemplateCallback::templateForEmbeddedMessage(AbstractMessagePart * part)
+{
+    JNIEnv * env = mEnv;
+    jclass cls = mEnv->GetObjectClass(mCallback);
+    jmethodID mid = mEnv->GetMethodID(cls, "templateForEmbeddedMessage", "(Lcom/libmailcore/AbstractMessagePart;)Ljava/lang/String;");
+    return MC_FROM_JAVA(String, mEnv->CallObjectMethod(mCallback, mid, MC_TO_JAVA(part)));
+}
+    
+String * JavaHTMLRendererTemplateCallback::templateForEmbeddedMessageHeader(MessageHeader * header)
+{
+    JNIEnv * env = mEnv;
+    jclass cls = mEnv->GetObjectClass(mCallback);
+    jmethodID mid = mEnv->GetMethodID(cls, "templateForEmbeddedMessageHeader", "(Lcom/libmailcore/MessageHeader;)Ljava/lang/String;");
+    return MC_FROM_JAVA(String, mEnv->CallObjectMethod(mCallback, mid, MC_TO_JAVA(header)));
+}
+    
+String * JavaHTMLRendererTemplateCallback::templateForAttachmentSeparator()
+{
+    JNIEnv * env = mEnv;
+    jclass cls = mEnv->GetObjectClass(mCallback);
+    jmethodID mid = mEnv->GetMethodID(cls, "templateForAttachmentSeparator", "()Ljava/lang/String;");
+    return MC_FROM_JAVA(String, mEnv->CallObjectMethod(mCallback, mid));
+}
+    
+String * JavaHTMLRendererTemplateCallback::cleanHTMLForPart(String * html)
+{
+    JNIEnv * env = mEnv;
+    jclass cls = mEnv->GetObjectClass(mCallback);
+    jmethodID mid = mEnv->GetMethodID(cls, "cleanHTMLForPart", "(Ljava/lang/String;)Ljava/lang/String;");
+    return MC_FROM_JAVA(String, mEnv->CallObjectMethod(mCallback, mid, MC_TO_JAVA(html)));
+}
+
+String * JavaHTMLRendererTemplateCallback::filterHTMLForPart(String * html)
+{
+    JNIEnv * env = mEnv;
+    jclass cls = mEnv->GetObjectClass(mCallback);
+    jmethodID mid = mEnv->GetMethodID(cls, "filterHTMLForPart", "(Ljava/lang/String;)Ljava/lang/String;");
+    return MC_FROM_JAVA(String, mEnv->CallObjectMethod(mCallback, mid, MC_TO_JAVA(html)));
+}
+    
+String * JavaHTMLRendererTemplateCallback::filterHTMLForMessage(String * html)
+{
+    JNIEnv * env = mEnv;
+    jclass cls = mEnv->GetObjectClass(mCallback);
+    jmethodID mid = mEnv->GetMethodID(cls, "filterHTMLForMessage", "(Ljava/lang/String;)Ljava/lang/String;");
+    return MC_FROM_JAVA(String, mEnv->CallObjectMethod(mCallback, mid, MC_TO_JAVA(html)));
+}
+    
+JavaHTMLRendererTemplateCallback::JavaHTMLRendererTemplateCallback(JNIEnv * env, jobject callback)
+{
+    mCallback = callback;
+    mEnv = env;
+}
diff --git a/src/java/JavaHTMLRendererTemplateCallback.h b/src/java/JavaHTMLRendererTemplateCallback.h
new file mode 100644
index 00000000..f32ca97a
--- /dev/null
+++ b/src/java/JavaHTMLRendererTemplateCallback.h
@@ -0,0 +1,38 @@
+#ifndef MAILCORE_JAVA_HTML_RENDERER_TEMPLATE_CALLBACK_H
+
+#define MAILCORE_JAVA_HTML_RENDERER_TEMPLATE_CALLBACK_H
+
+#include <jni.h>
+
+#include "MCBaseTypes.h"
+#include "MCHTMLRendererCallback.h"
+
+namespace mailcore {
+
+class JavaHTMLRendererTemplateCallback : public Object, public HTMLRendererTemplateCallback {
+public:
+    JavaHTMLRendererTemplateCallback(JNIEnv * env, jobject listener);
+    
+    virtual bool canPreviewPart(AbstractPart * part);
+    virtual bool shouldShowPart(AbstractPart * part);
+    virtual HashMap * templateValuesForHeader(MessageHeader * header);
+    virtual HashMap * templateValuesForPart(AbstractPart * part);
+    virtual String * templateForMainHeader(MessageHeader * header);
+    virtual String * templateForImage(AbstractPart * part);
+    virtual String * templateForAttachment(AbstractPart * part);
+    virtual String * templateForMessage(AbstractMessage * message);
+    virtual String * templateForEmbeddedMessage(AbstractMessagePart * part);
+    virtual String * templateForEmbeddedMessageHeader(MessageHeader * header);
+    virtual String * templateForAttachmentSeparator();
+    virtual String * cleanHTMLForPart(String * html);
+    virtual String * filterHTMLForPart(String * html);
+    virtual String * filterHTMLForMessage(String * html);
+    
+private:
+    jobject mCallback;
+    JNIEnv * mEnv;
+};
+
+}
+
+#endif
diff --git a/src/java/JavaHandle.cpp b/src/java/JavaHandle.cpp
new file mode 100644
index 00000000..4f02323e
--- /dev/null
+++ b/src/java/JavaHandle.cpp
@@ -0,0 +1,43 @@
+#include "JavaHandle.h"
+
+using namespace mailcore;
+
+static jfieldID getField(JNIEnv * env, jobject obj, const char * fieldName)
+{
+    jclass c = env->GetObjectClass(obj);
+    return env->GetFieldID(c, fieldName, "J");
+}
+
+static jfieldID getHandleField(JNIEnv * env, jobject obj)
+{
+    return getField(env, obj, "nativeHandle");
+}
+
+void * mailcore::getHandle(JNIEnv * env, jobject obj)
+{
+    jlong handle = env->GetLongField(obj, getHandleField(env, obj));
+    return (void *) handle;
+}
+
+void mailcore::setHandle(JNIEnv *env, jobject obj, void *t)
+{
+    jlong handle = reinterpret_cast<jlong>(t);
+    env->SetLongField(obj, getHandleField(env, obj), handle);
+}
+
+void * mailcore::getCustomHandle(JNIEnv * env, jobject obj, const char * fieldName)
+{
+    jlong handle = env->GetLongField(obj, getField(env, obj, fieldName));
+    return (void *) handle;
+}
+
+void mailcore::setCustomHandle(JNIEnv *env, jobject obj, const char * fieldName, void *t)
+{
+    jlong handle = reinterpret_cast<jlong>(t);
+    env->SetLongField(obj, getField(env, obj, fieldName), handle);
+}
+
+jobject mailcore::getObjectField(JNIEnv *env, jobject obj, const char * fieldName)
+{
+    return env->GetObjectField(obj, getField(env, obj, fieldName));
+}
\ No newline at end of file
diff --git a/src/java/JavaHandle.h b/src/java/JavaHandle.h
new file mode 100644
index 00000000..19e8aee8
--- /dev/null
+++ b/src/java/JavaHandle.h
@@ -0,0 +1,15 @@
+#ifndef MAILCORE_JAVA_HANDLE_H
+
+#define MAILCORE_JAVA_HANDLE_H
+
+#include <jni.h>
+
+namespace mailcore {
+    void * getHandle(JNIEnv * env, jobject obj);
+    void setHandle(JNIEnv * env, jobject obj, void * t);
+    void * getCustomHandle(JNIEnv * env, jobject obj, const char * fieldName);
+    void setCustomHandle(JNIEnv *env, jobject obj, const char * fieldName, void *t);
+    jobject getObjectField(JNIEnv *env, jobject obj, const char * fieldName);
+}
+
+#endif
diff --git a/src/java/JavaIMAPOperationCallback.cpp b/src/java/JavaIMAPOperationCallback.cpp
new file mode 100644
index 00000000..fba857b8
--- /dev/null
+++ b/src/java/JavaIMAPOperationCallback.cpp
@@ -0,0 +1,45 @@
+#include "JavaIMAPOperationCallback.h"
+
+using namespace mailcore;
+
+static bool isIMAPOperationProgressListener(JNIEnv * env, jobject obj)
+{
+    jclass cls = env->FindClass("com/libmailcore/IMAPOperationProgressListener");
+    return env->IsInstanceOf(obj, cls);
+}
+
+static bool isIMAPOperationItemProgressListener(JNIEnv * env, jobject obj)
+{
+    jclass cls = env->FindClass("com/libmailcore/IMAPOperationItemProgressListener");
+    return env->IsInstanceOf(obj, cls);
+}
+
+JavaIMAPOperationCallback::JavaIMAPOperationCallback(JNIEnv * env, jobject listener)
+{
+    mEnv = env;
+    mListener = listener;
+}
+
+void JavaIMAPOperationCallback::bodyProgress(IMAPOperation * session, unsigned int current, unsigned int maximum)
+{
+    if (!isIMAPOperationProgressListener(mEnv, mListener)) {
+        return;
+    }
+
+    JNIEnv * env = mEnv;
+    jclass cls = mEnv->GetObjectClass(mListener);
+    jmethodID mid = mEnv->GetMethodID(cls, "bodyProgress", "(JJ)V");
+    mEnv->CallVoidMethod(mListener, mid);
+}
+
+void JavaIMAPOperationCallback::itemProgress(IMAPOperation * session, unsigned int current, unsigned int maximum)
+{
+    if (!isIMAPOperationItemProgressListener(mEnv, mListener)) {
+        return;
+    }
+
+    JNIEnv * env = mEnv;
+    jclass cls = mEnv->GetObjectClass(mListener);
+    jmethodID mid = mEnv->GetMethodID(cls, "itemProgress", "(JJ)V");
+    mEnv->CallVoidMethod(mListener, mid);
+}
diff --git a/src/java/JavaIMAPOperationCallback.h b/src/java/JavaIMAPOperationCallback.h
new file mode 100644
index 00000000..b1f72620
--- /dev/null
+++ b/src/java/JavaIMAPOperationCallback.h
@@ -0,0 +1,29 @@
+#ifndef MAILCORE_JAVA_IMAP_OPERATION_CALLBACK_H
+
+#define MAILCORE_JAVA_IMAP_OPERATION_CALLBACK_H
+
+#include <jni.h>
+#include "MCBaseTypes.h"
+#include "MCIMAPOperationCallback.h"
+
+#ifdef __cplusplus
+
+namespace mailcore {
+    
+    class JavaIMAPOperationCallback : public Object, public IMAPOperationCallback {
+    public:
+        JavaIMAPOperationCallback(JNIEnv * env, jobject listener);
+        
+        virtual void bodyProgress(IMAPOperation * session, unsigned int current, unsigned int maximum);
+        virtual void itemProgress(IMAPOperation * session, unsigned int current, unsigned int maximum);
+        
+    private:
+        JNIEnv * mEnv;
+        jobject mListener;
+    };
+    
+}
+
+#endif
+
+#endif
diff --git a/src/java/JavaOperationQueueCallback.cpp b/src/java/JavaOperationQueueCallback.cpp
new file mode 100644
index 00000000..bdfe59eb
--- /dev/null
+++ b/src/java/JavaOperationQueueCallback.cpp
@@ -0,0 +1,25 @@
+#include "JavaOperationQueueCallback.h"
+
+using namespace mailcore;
+
+JavaOperationQueueCallback::JavaOperationQueueCallback(JNIEnv * env, jobject listener)
+{
+    mListener = listener;
+    mEnv = env;
+}
+
+void JavaOperationQueueCallback::queueStartRunning()
+{
+    JNIEnv * env = mEnv;
+    jclass cls = mEnv->GetObjectClass(mListener);
+    jmethodID mid = mEnv->GetMethodID(cls, "queueStartRunning", "()V");
+    mEnv->CallVoidMethod(mListener, mid);
+}
+
+void JavaOperationQueueCallback::queueStoppedRunning()
+{
+    JNIEnv * env = mEnv;
+    jclass cls = mEnv->GetObjectClass(mListener);
+    jmethodID mid = mEnv->GetMethodID(cls, "queueStoppedRunning", "()V");
+    mEnv->CallVoidMethod(mListener, mid);
+}
diff --git a/src/java/JavaOperationQueueCallback.h b/src/java/JavaOperationQueueCallback.h
new file mode 100644
index 00000000..ef6fcf68
--- /dev/null
+++ b/src/java/JavaOperationQueueCallback.h
@@ -0,0 +1,25 @@
+#ifndef MAILCORE_JAVA_OPERATION_QUEUE_CALLBACK_H
+
+#define MAILCORE_JAVA_OPERATION_QUEUE_CALLBACK_H
+
+#include <jni.h>
+#include "MCBaseTypes.h"
+#include "MCOperationQueueCallback.h"
+
+namespace mailcore {
+
+class JavaOperationQueueCallback : public Object, public OperationQueueCallback {
+public:
+    JavaOperationQueueCallback(JNIEnv * env, jobject listener);
+    
+    virtual void queueStartRunning();
+    virtual void queueStoppedRunning();
+    
+private:
+    jobject mListener;
+    JNIEnv * mEnv;
+};
+
+}
+
+#endif
diff --git a/src/java/TypesUtils.cpp b/src/java/TypesUtils.cpp
new file mode 100644
index 00000000..7c500e84
--- /dev/null
+++ b/src/java/TypesUtils.cpp
@@ -0,0 +1,518 @@
+#include "TypesUtils.h"
+
+#include "MCValuePrivate.h"
+#include "JavaHandle.h"
+#include <libetpan/libetpan.h>
+#include "MCDefines.h"
+#include "MCLog.h"
+
+using namespace mailcore;
+
+static chash * cppClassHash = NULL;
+static chash * javaClassHash = NULL;
+
+/*
+         case jniBoolean: name += "Z"; break;
+         case jniVoid: name += "V"; break;
+         case jniByte: name += "B"; break;
+         case jniChar: name += "C"; break;
+         case jniShort: name += "S"; break;
+         case jniInt: name += "I"; break;
+         case jniLong: name += "J"; break;
+         case jniFloat: name += "F"; break;
+         case jniDouble: name += "D"; break;
+*/
+
+static void init(void);
+static void real_init(void);
+
+jobject mailcore::rangeToJava(JNIEnv * env, Range range)
+{
+    jclass cls = env->FindClass("com/libmailcore/Range");
+    jmethodID constructor = env->GetMethodID(cls, "<init>", "(JJ)V");
+    jobject javaObject = env->NewObject(cls, constructor, (jlong) range.location, (jlong) range.length);
+    return javaObject;
+}
+
+Range mailcore::rangeFromJava(JNIEnv * env, jobject obj)
+{
+    jclass cls = env->GetObjectClass(obj);
+    jfieldID locationField = env->GetFieldID(cls, "location", "J");
+    jfieldID lengthField = env->GetFieldID(cls, "length", "J");
+    jlong location = env->GetLongField(obj, locationField);
+    jlong length = env->GetLongField(obj, lengthField);
+    return RangeMake((uint64_t) location, (uint64_t) length);
+}
+
+time_t mailcore::javaDateToTime(JNIEnv * env, jobject date)
+{
+    jclass javaClass = env->GetObjectClass(date);
+    jmethodID method = env->GetMethodID(javaClass, "getTime", "()J");
+    jlong value = env->CallLongMethod(date, method);
+    return (time_t) (value / 1000LL);
+}
+
+jobject mailcore::timeToJavaDate(JNIEnv * env, time_t t)
+{
+    jclass cls = env->FindClass("java/util/Date");
+    jmethodID constructor = env->GetMethodID(cls, "<init>", "(J)V");
+    jobject javaDate = env->NewObject(cls, constructor, ((jlong) t ) * 1000LL);
+    return javaDate;
+}
+
+void mailcore::MCJNIRegisterNativeClass(const std::type_info * info, ObjectToJavaConverter converter)
+{
+    MCLogEnabled = 1;
+    MCLog("MCJNIRegisterNativeClass");
+    init();
+    
+    chashdatum key;
+    chashdatum value;
+    MCLog("info: %p", info);
+#ifdef __LIBCPP_TYPEINFO
+    size_t hash_value = info->hash_code();
+    MCLog("info hash: %i", (int) hash_value);
+    key.data = &hash_value;
+    key.len = sizeof(hash_value);
+#else
+    MCLog("info name: %s", info->name());
+    key.data = (void *) info->name();
+    key.len = (unsigned int) strlen(info->name());
+#endif
+    value.data = (void *) converter;
+    value.len = 0;
+    chash_set(cppClassHash, &key, &value, NULL);
+}
+
+void mailcore::MCJNIRegisterJavaClass(const char * className, JavaToObjectConverter converter)
+{
+    MCLogEnabled = 1;
+    MCLog("MCJNIRegisterJavaClass %s", className);
+    init();
+    
+    chashdatum key;
+    chashdatum value;
+    key.data = (void *) className;
+    key.len = strlen(className);
+    value.data = (void *) converter;
+    value.len = 0;
+    chash_set(javaClassHash, &key, &value, NULL);
+}
+
+static jobject valueObjectToJavaConverter(JNIEnv * env, Object * obj)
+{
+    jclass cls;
+    jmethodID constructor;
+    Value * value = (Value *) obj;
+    jobject result;
+    switch (value->type()) {
+        // boolean, byte, character, long, int, short, double, float
+        case mailcore::ValueTypeNone:
+        MCAssert(0);
+        break;
+        case mailcore::ValueTypeBool:
+        // bool
+        cls = env->FindClass("java/util/Boolean");
+        constructor = env->GetMethodID(cls, "<init>", "(Z)V");
+        result = env->NewObject(cls, constructor, value->boolValue());
+        break;
+        case mailcore::ValueTypeChar:
+        // byte
+        cls = env->FindClass("java/util/Byte");
+        constructor = env->GetMethodID(cls, "<init>", "(B)V");
+        result = env->NewObject(cls, constructor, value->charValue());
+        break;
+        case mailcore::ValueTypeUnsignedChar:
+        // short
+        cls = env->FindClass("java/util/Short");
+        constructor = env->GetMethodID(cls, "<init>", "(S)V");
+        result = env->NewObject(cls, constructor, value->unsignedCharValue());
+        break;
+        case mailcore::ValueTypeShort:
+        // short
+        cls = env->FindClass("java/util/Short");
+        constructor = env->GetMethodID(cls, "<init>", "(S)V");
+        result = env->NewObject(cls, constructor, value->shortValue());
+        break;
+        case mailcore::ValueTypeUnsignedShort:
+        // int
+        cls = env->FindClass("java/util/Integer");
+        constructor = env->GetMethodID(cls, "<init>", "(I)V");
+        result = env->NewObject(cls, constructor, value->intValue());
+        break;
+        case mailcore::ValueTypeInt:
+        // int
+        cls = env->FindClass("java/util/Integer");
+        constructor = env->GetMethodID(cls, "<init>", "(I)V");
+        result = env->NewObject(cls, constructor, value->intValue());
+        break;
+        case mailcore::ValueTypeUnsignedInt:
+        // long
+        cls = env->FindClass("java/util/Long");
+        constructor = env->GetMethodID(cls, "<init>", "(J)V");
+        result = env->NewObject(cls, constructor, value->unsignedIntValue());
+        break;
+        case mailcore::ValueTypeLong:
+        // long
+        cls = env->FindClass("java/util/Long");
+        constructor = env->GetMethodID(cls, "<init>", "(J)V");
+        result = env->NewObject(cls, constructor, value->longValue());
+        break;
+        case mailcore::ValueTypeUnsignedLong:
+        // long
+        cls = env->FindClass("java/util/Long");
+        constructor = env->GetMethodID(cls, "<init>", "(J)V");
+        result = env->NewObject(cls, constructor, value->unsignedLongValue());
+        break;
+        case mailcore::ValueTypeLongLong:
+        // long
+        cls = env->FindClass("java/util/Long");
+        constructor = env->GetMethodID(cls, "<init>", "(J)V");
+        result = env->NewObject(cls, constructor, value->longLongValue());
+        break;
+        case mailcore::ValueTypeUnsignedLongLong:
+        // long - might break
+        cls = env->FindClass("java/util/Long");
+        constructor = env->GetMethodID(cls, "<init>", "(J)V");
+        result = env->NewObject(cls, constructor, value->unsignedLongLongValue());
+        break;
+        case mailcore::ValueTypeFloat:
+        // float
+        cls = env->FindClass("java/util/Float");
+        constructor = env->GetMethodID(cls, "<init>", "(F)V");
+        result = env->NewObject(cls, constructor, value->floatValue());
+        break;
+        case mailcore::ValueTypeDouble:
+        // double
+        cls = env->FindClass("java/util/Double");
+        constructor = env->GetMethodID(cls, "<init>", "(D)V");
+        result = env->NewObject(cls, constructor, value->doubleValue());
+        break;
+        case mailcore::ValueTypePointer:
+        MCAssert(0);
+        break;
+        case mailcore::ValueTypeData:
+        MCAssert(0);
+        break;
+    }
+    return result;
+}
+
+static jobject dataObjectToJavaConverter(JNIEnv * env, Object * obj)
+{
+    Data * data = (Data *) obj;
+    jbyteArray result = env->NewByteArray(data->length());
+    env->SetByteArrayRegion(result, 0, (jsize) data->length(), (const jbyte *) data->bytes());
+    return result;
+}
+
+static jobject stringObjectToJavaConverter(JNIEnv * env, Object * obj)
+{
+    String * str = (String *) obj;
+    return env->NewString((const jchar *) str->unicodeCharacters(), (jsize) str->length());
+}
+
+static jobject hashmapObjectToJavaConverter(JNIEnv * env, Object * obj)
+{
+    HashMap * hashMap = (HashMap *) obj;
+    jclass cls = env->FindClass("java/util/HashMap");
+    jmethodID constructor = env->GetMethodID(cls, "<init>", "(I)V");
+    jobject javaHashMap = env->NewObject(cls, constructor, hashMap->count());
+    jmethodID method = env->GetMethodID(cls, "put", "(Ljava/lang/Object;Ljava/lang/Object;)V");
+    Array * keys = hashMap->allKeys();
+    for(unsigned int i = 0 ; i < keys->count() ; i ++) {
+        Object * key = keys->objectAtIndex(i);
+        jobject javaKey = mcObjectToJava(env, key);
+        Object * value = hashMap->objectForKey(key);
+        jobject javaValue = mcObjectToJava(env, value);
+        env->CallVoidMethod(javaHashMap, method, javaKey, javaValue);
+    }
+    return javaHashMap;
+}
+
+static jobject arrayObjectToJavaConverter(JNIEnv * env, Object * obj)
+{
+    Array * array = (Array *) obj;
+    jclass cls = env->FindClass("java/util/Vector");
+    jmethodID constructor = env->GetMethodID(cls, "<init>", "(I)V");
+    jobject javaVector = env->NewObject(cls, constructor, array->count());
+    jmethodID method = env->GetMethodID(cls, "add", "(Ljava/lang/Object;)Z");
+    MCLog("add method %p", method);
+    for(unsigned int i = 0 ; i < array->count() ; i ++) {
+        MCLog("converting object %s", MCUTF8(array->objectAtIndex(i)));
+        jobject javaObject = mcObjectToJava(env, array->objectAtIndex(i));
+        MCLog("add object %p", javaObject);
+        env->CallBooleanMethod(javaVector, method, javaObject);
+        MCLog("added object %p", javaObject);
+    }
+    MCLog("array converted");
+    return javaVector;
+}
+
+static Object * booleanJavaToObjectConverter(JNIEnv * env, jobject obj)
+{
+    jclass javaClass = env->GetObjectClass(obj);
+    jmethodID method = env->GetMethodID(javaClass, "booleanValue", "()B");
+    jboolean value = env->CallBooleanMethod(obj, method);
+    return Value::valueWithBoolValue(value);
+}
+
+static Object * byteJavaToObjectConverter(JNIEnv * env, jobject obj)
+{
+    jclass javaClass = env->GetObjectClass(obj);
+    jmethodID method = env->GetMethodID(javaClass, "byteValue", "()B");
+    jbyte value = env->CallByteMethod(obj, method);
+    return Value::valueWithShortValue(value);
+}
+
+static Object * characterJavaToObjectConverter(JNIEnv * env, jobject obj)
+{
+    jclass javaClass = env->GetObjectClass(obj);
+    jmethodID method = env->GetMethodID(javaClass, "charValue", "()C");
+    jchar value = env->CallCharMethod(obj, method);
+    return Value::valueWithShortValue(value);
+}
+
+static Object * longJavaToObjectConverter(JNIEnv * env, jobject obj)
+{
+    jclass javaClass = env->GetObjectClass(obj);
+    jmethodID method = env->GetMethodID(javaClass, "longValue", "()J");
+    jlong value = env->CallLongMethod(obj, method);
+    return Value::valueWithLongLongValue(value);
+}
+
+static Object * integerJavaToObjectConverter(JNIEnv * env, jobject obj)
+{
+    jclass javaClass = env->GetObjectClass(obj);
+    jmethodID method = env->GetMethodID(javaClass, "intValue", "()I");
+    jint value = env->CallIntMethod(obj, method);
+    return Value::valueWithIntValue(value);
+}
+
+static Object * shortJavaToObjectConverter(JNIEnv * env, jobject obj)
+{
+    jclass javaClass = env->GetObjectClass(obj);
+    jmethodID method = env->GetMethodID(javaClass, "shortValue", "()S");
+    jshort value = env->CallShortMethod(obj, method);
+    return Value::valueWithShortValue(value);
+}
+
+static Object * doubleJavaToObjectConverter(JNIEnv * env, jobject obj)
+{
+    jclass javaClass = env->GetObjectClass(obj);
+    jmethodID method = env->GetMethodID(javaClass, "doubleValue", "()D");
+    jdouble value = env->CallDoubleMethod(obj, method);
+    return Value::valueWithDoubleValue(value);
+}
+
+static Object * floatJavaToObjectConverter(JNIEnv * env, jobject obj)
+{
+    jclass javaClass = env->GetObjectClass(obj);
+    jmethodID method = env->GetMethodID(javaClass, "floatValue", "()F");
+    jfloat value = env->CallFloatMethod(obj, method);
+    return Value::valueWithFloatValue(value);
+}
+
+static Object * dataJavaToObjectConverter(JNIEnv * env, jobject obj)
+{
+    jsize len = env->GetArrayLength((jarray) obj);
+    jbyte * bytes = env->GetByteArrayElements((jbyteArray) obj, NULL);
+    Data * result = Data::dataWithBytes((const char *) bytes, len);
+    env->ReleaseByteArrayElements((jbyteArray) obj, bytes, 0);
+    return result;
+}
+
+static Object * stringJavaToObjectConverter(JNIEnv * env, jobject obj)
+{
+    jsize len = env->GetStringLength((jstring) obj);
+    const jchar * chars = env->GetStringChars((jstring) obj, NULL);
+    String * result = String::stringWithCharacters(chars, len);
+    env->ReleaseStringChars((jstring) obj, chars);
+    return result;
+}
+
+static bool isJavaMap(JNIEnv * env, jobject obj)
+{
+    jclass cls = env->FindClass("java/util/Map");
+    return env->IsInstanceOf(obj, cls);
+}
+
+static Object * hashmapJavaToObjectConverter(JNIEnv * env, jobject obj)
+{
+    HashMap * result = HashMap::hashMap();
+    jclass javaClass = env->GetObjectClass(obj);
+    jmethodID method = env->GetMethodID(javaClass, "entrySet", "()Ljava/util/Set;");
+    jobject entrySet = (jobjectArray) env->CallObjectMethod(obj, method);
+    javaClass = env->GetObjectClass(entrySet);
+    method = env->GetMethodID(javaClass, "toArray", "()[Ljava/lang/Object;");
+    jobjectArray array = (jobjectArray) env->CallObjectMethod(obj, method);
+    int count = (int) env->GetArrayLength(array);
+    for(int i = 0 ; i < count ; i ++) {
+        jobject entry = env->GetObjectArrayElement(array, i);
+        javaClass = env->GetObjectClass(entry);
+        method = env->GetMethodID(javaClass, "getKey", "()Ljava/lang/Object;");
+        jobject key = env->CallObjectMethod(obj, method);
+        Object * mcKey = javaToMCObject(env, key);
+        method = env->GetMethodID(javaClass, "getValue", "()Ljava/lang/Object;");
+        jobject value = env->CallObjectMethod(obj, method);
+        Object * mcValue = javaToMCObject(env, value);
+        result->setObjectForKey(mcKey, mcValue);
+    }
+    return result;
+}
+
+static bool isJavaList(JNIEnv * env, jobject obj)
+{
+    jclass cls = env->FindClass("java/util/List");
+    return env->IsInstanceOf(obj, cls);
+}
+
+static Object * arrayJavaToObjectConverter(JNIEnv * env, jobject obj)
+{
+    Array * result = Array::array();
+    jclass javaClass = env->GetObjectClass(obj);
+    jmethodID method = env->GetMethodID(javaClass, "toArray", "()[Ljava/lang/Object;");
+    jobjectArray array = (jobjectArray) env->CallObjectMethod(obj, method);
+    int count = (int) env->GetArrayLength(array);
+    for(int i = 0 ; i < count ; i ++) {
+        jobject item = env->GetObjectArrayElement(array, i);
+        Object * mcItem = javaToMCObject(env, item);
+        result->addObject(mcItem);
+    }
+    return result;
+}
+
+static bool isNativeObject(JNIEnv * env, jobject obj)
+{
+    jclass cls = env->FindClass("com/libmailcore/NativeObject");
+    return env->IsInstanceOf(obj, cls);
+}
+
+static void setupBasicConverters(void)
+{
+    MCLog("register value");
+    MCJNIRegisterNativeClass(&typeid(mailcore::Value), (ObjectToJavaConverter *) valueObjectToJavaConverter);
+    MCLog("register data");
+    MCJNIRegisterNativeClass(&typeid(mailcore::Data), (ObjectToJavaConverter *) dataObjectToJavaConverter);
+    MCLog("register string");
+    MCJNIRegisterNativeClass(&typeid(mailcore::String), (ObjectToJavaConverter *) stringObjectToJavaConverter);
+    MCLog("register hashmap");
+    MCJNIRegisterNativeClass(&typeid(mailcore::HashMap), (ObjectToJavaConverter *) hashmapObjectToJavaConverter);
+    MCLog("register array");
+    MCJNIRegisterNativeClass(&typeid(mailcore::Array), (ObjectToJavaConverter *) arrayObjectToJavaConverter);
+    
+    MCLog("register java bool");
+    MCJNIRegisterJavaClass("java.lang.Boolean", (JavaToObjectConverter *) booleanJavaToObjectConverter);
+    MCLog("register java byte");
+    MCJNIRegisterJavaClass("java.lang.Byte", (JavaToObjectConverter *) byteJavaToObjectConverter);
+    MCLog("register java char");
+    MCJNIRegisterJavaClass("java.lang.Character", (JavaToObjectConverter *) characterJavaToObjectConverter);
+    MCLog("register java long");
+    MCJNIRegisterJavaClass("java.lang.Long", (JavaToObjectConverter *) longJavaToObjectConverter);
+    MCLog("register java int");
+    MCJNIRegisterJavaClass("java.lang.Integer", (JavaToObjectConverter *) integerJavaToObjectConverter);
+    MCLog("register java short");
+    MCJNIRegisterJavaClass("java.lang.Short", (JavaToObjectConverter *) shortJavaToObjectConverter);
+    MCLog("register java double");
+    MCJNIRegisterJavaClass("java.lang.Double", (JavaToObjectConverter *) doubleJavaToObjectConverter);
+    MCLog("register java float");
+    MCJNIRegisterJavaClass("java.lang.Float", (JavaToObjectConverter *) floatJavaToObjectConverter);
+    MCLog("register java array of bytes");
+    MCJNIRegisterJavaClass("[B", (JavaToObjectConverter *) dataJavaToObjectConverter);
+    MCLog("register java string");
+    MCJNIRegisterJavaClass("java.lang.String", (JavaToObjectConverter *) stringJavaToObjectConverter);
+}
+
+Object * mailcore::javaToMCObject(JNIEnv * env, jobject obj)
+{
+    if (obj == NULL) {
+        return NULL;
+    }
+    
+    if (isNativeObject(env, obj)) {
+        return (Object *) getHandle(env, obj);
+    }
+    else if (isJavaMap(env, obj)) {
+        return hashmapJavaToObjectConverter(env, obj);
+    }
+    else if (isJavaMap(env, obj)) {
+        return arrayJavaToObjectConverter(env, obj);
+    }
+    else {
+        Object * result = NULL;
+        
+        jclass javaClass = env->GetObjectClass(obj);
+        jclass classClass = env->GetObjectClass(javaClass);
+        jmethodID mid = env->GetMethodID(classClass, "getName", "()Ljava/lang/String;");
+        jstring strObj = (jstring) env->CallObjectMethod(javaClass, mid);
+        const char * str = env->GetStringUTFChars(strObj, NULL);
+        MCLog("class: %s", str);
+        chashdatum key;
+        chashdatum value;
+        key.data = (void *) str;
+        key.len = strlen(str);
+        int r = chash_get(javaClassHash, &key, &value);
+        if (r == 0) {
+            JavaToObjectConverter * converter = (JavaToObjectConverter *) value.data;
+            result = converter(env, obj);
+            MCLog("result: %s", MCUTF8(result));
+        }
+        else {
+            MCLog("converter not found: %s", str);
+            MCAssert(0);
+        }
+        env->ReleaseStringUTFChars(strObj, str);
+        
+        return result;
+    }
+}
+
+jobject mailcore::mcObjectToJava(JNIEnv * env, Object * obj)
+{
+    MCLog("converter to java: %s", MCUTF8(obj));
+    if (obj == NULL) {
+        return NULL;
+    }
+    
+    const std::type_info * info = &typeid(* obj);
+    chashdatum key;
+    chashdatum value;
+#ifdef __LIBCPP_TYPEINFO
+    size_t hash_value = info->hash_code();
+    MCLog("converter to java: %i", (int) hash_value);
+    key.data = &hash_value;
+    key.len = sizeof(hash_value);
+#else
+    key.data = (void *) info->name();
+    key.len = (unsigned int) strlen(info->name());
+#endif
+    int r = chash_get(cppClassHash, &key, &value);
+    if (r < 0) {
+        MCLog("converter not found: %s", MCUTF8(obj));
+        MCAssert(0);
+    }
+    ObjectToJavaConverter * converter = (ObjectToJavaConverter *) value.data;
+    return converter(env, obj);
+}
+
+static void init(void)
+{
+    static pthread_once_t once = PTHREAD_ONCE_INIT;
+    pthread_once(&once, real_init);
+}
+
+static void real_init(void)
+{
+    MCLogEnabled = 1;
+    MCLog("real_init");
+    MCLog("init cppClassHash");
+    cppClassHash = chash_new(CHASH_DEFAULTSIZE, CHASH_COPYKEY);
+    MCLog("init javaClassHash");
+    javaClassHash = chash_new(CHASH_DEFAULTSIZE, CHASH_COPYKEY);
+}
+
+void mailcore::MCTypesUtilsInit(void)
+{
+    MCLog("basic converters");
+    setupBasicConverters();
+}
diff --git a/src/java/TypesUtils.h b/src/java/TypesUtils.h
new file mode 100644
index 00000000..67430c72
--- /dev/null
+++ b/src/java/TypesUtils.h
@@ -0,0 +1,120 @@
+#ifndef MAILCORE_TYPES_UTILS_H
+
+#define MAILCORE_TYPES_UTILS_H
+
+#include <typeinfo>
+#include <jni.h>
+#include "MCBaseTypes.h"
+#include "MCDefines.h"
+#include "MCRange.h"
+
+#define MC_TO_JAVA(obj) mailcore::mcObjectToJava(env, (Object *) obj)
+#define MC_FROM_JAVA(type, obj) ((type *) mailcore::javaToMCObject(env, (jobject) obj))
+#define MC_JAVA_NATIVE_INSTANCE ((nativeType *) mailcore::getHandle(env, obj))
+#define MC_JAVA_BRIDGE_GET(getter) MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->getter())
+#define MC_JAVA_BRIDGE_GET_STRING(getter) ((jstring) MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->getter()))
+#define MC_JAVA_BRIDGE_GET_DATA(getter) ((jbyteArray) MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->getter()))
+#define MC_JAVA_BRIDGE_GET_SCALAR(javaScalarType, getter) ((javaScalarType) MC_JAVA_NATIVE_INSTANCE->getter())
+
+#define MC_JAVA_SYNTHESIZE(type, setter, getter) MC_JAVA_SYNTHESIZE_internal(type, javaType, setter, getter)
+#define MC_JAVA_SYNTHESIZE_STRING(setter, getter) MC_JAVA_SYNTHESIZE_STRING_internal(javaType, setter, getter)
+#define MC_JAVA_SYNTHESIZE_DATA(setter, getter) MC_JAVA_SYNTHESIZE_DATA_internal(javaType, setter, getter)
+#define MC_JAVA_SYNTHESIZE_SCALAR(javaScalarType, scalarType, setter, getter) MC_JAVA_SYNTHESIZE_SCALAR_internal(javaScalarType, scalarType, javaType, setter, getter)
+#define MC_JAVA_BRIDGE MC_JAVA_BRIDGE_internal(javaType, nativeType)
+
+#define MC_JAVA_CONCAT(a, b) a ## b
+//#define prefix MC_JAVA_CONCAT(prefix1, _)
+//#define prefix(nativeType) Java_com_libmailcore_ ## nativeType ## _
+#define prefixed_function(javaType, function_name) Java_com_libmailcore_ ## javaType ## _ ## function_name
+
+#define MC_JAVA_SYNTHESIZE_internal(type, javaType, setter, getter) \
+    JNIEXPORT jobject JNICALL prefixed_function(javaType, getter) (JNIEnv * env, jobject obj) \
+    { \
+        return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->getter()); \
+    } \
+    \
+    JNIEXPORT void JNICALL prefixed_function(javaType, setter) (JNIEnv * env, jobject obj, jobject value) \
+    { \
+        MC_JAVA_NATIVE_INSTANCE->setter(MC_FROM_JAVA(type, value)); \
+    }
+
+#define MC_JAVA_SYNTHESIZE_STRING_internal(javaType, setter, getter) \
+    JNIEXPORT jstring JNICALL prefixed_function(javaType, getter) (JNIEnv * env, jobject obj) \
+    { \
+        return (jstring) MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->getter()); \
+    } \
+    \
+    JNIEXPORT void JNICALL prefixed_function(javaType, setter) (JNIEnv * env, jobject obj, jstring value) \
+    { \
+        MC_JAVA_NATIVE_INSTANCE->setter(MC_FROM_JAVA(String, value)); \
+    }
+
+#define MC_JAVA_SYNTHESIZE_DATA_internal(javaType, setter, getter) \
+    JNIEXPORT jbyteArray JNICALL prefixed_function(javaType, getter) (JNIEnv * env, jobject obj) \
+    { \
+        return (jbyteArray) MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->getter()); \
+    } \
+    \
+    JNIEXPORT void JNICALL prefixed_function(javaType, setter) (JNIEnv * env, jobject obj, jbyteArray value) \
+    { \
+        MC_JAVA_NATIVE_INSTANCE->setter(MC_FROM_JAVA(Data, value)); \
+    }
+
+#define MC_JAVA_SYNTHESIZE_SCALAR_internal(javaScalarType, scalarType, javaType, setter, getter) \
+    JNIEXPORT javaScalarType JNICALL prefixed_function(javaType, getter) (JNIEnv * env, jobject obj) \
+    { \
+        return (javaScalarType) MC_JAVA_NATIVE_INSTANCE->getter(); \
+    } \
+    \
+    JNIEXPORT void JNICALL prefixed_function(javaType, setter) (JNIEnv * env, jobject obj, javaScalarType value) \
+    { \
+        MC_JAVA_NATIVE_INSTANCE->setter((scalarType) value); \
+    }
+
+#define mc_quote(word) #word
+#define mc_expand_and_quote(word) mc_quote(word)
+
+#define MC_JAVA_BRIDGE_internal(javaType, nativeType) \
+    JNIEXPORT void JNICALL prefixed_function(javaType, setupNative) \
+      (JNIEnv * env, jobject obj) \
+    { \
+        setHandle(env, obj, new nativeType()); \
+    } \
+    \
+    static jobject objectToJavaConverter(JNIEnv * env, Object * obj) \
+    { \
+        jclass cls = env->FindClass("com/libmailcore/" mc_expand_and_quote(javaType)); \
+        jmethodID constructor = env->GetMethodID(cls, "initWithNative", "(J)V"); \
+        jobject javaObject = env->NewObject(cls, constructor, obj); \
+        return javaObject; \
+    } \
+    \
+    INITIALIZE(prefixed_function(javaType,)) \
+    { \
+        MCJNIRegisterNativeClass(&typeid(mailcore::nativeType), (ObjectToJavaConverter *) objectToJavaConverter); \
+    }
+
+namespace mailcore {
+    typedef jobject ObjectToJavaConverter(JNIEnv * env, Object * obj);
+    typedef Object * JavaToObjectConverter(JNIEnv * env, jobject obj);
+    
+    Object * javaToMCObject(JNIEnv * env, jobject obj);
+    jobject mcObjectToJava(JNIEnv * env, Object * obj);
+    
+    Range javaToRange(JNIEnv * env, jobject range);
+    jobject rangeToJava(JNIEnv * env, Range range);
+    
+    jobject errorToJava(int errorCode);
+    
+    time_t javaDateToTime(JNIEnv * env, jobject date);
+    jobject timeToJavaDate(JNIEnv * env, time_t t);
+    
+    jobject rangeToJava(JNIEnv * env, Range range);
+    Range rangeFromJava(JNIEnv * env, jobject obj);
+    
+    void MCJNIRegisterNativeClass(const std::type_info * info, ObjectToJavaConverter converter);
+    void MCJNIRegisterJavaClass(const char * className, JavaToObjectConverter converter);
+    void MCTypesUtilsInit(void);
+}
+
+#endif
diff --git a/src/java/com/libmailcore/.gitignore b/src/java/com/libmailcore/.gitignore
new file mode 100644
index 00000000..6b468b62
--- /dev/null
+++ b/src/java/com/libmailcore/.gitignore
@@ -0,0 +1 @@
+*.class
diff --git a/src/java/com/libmailcore/AbstractMessage.java b/src/java/com/libmailcore/AbstractMessage.java
new file mode 100644
index 00000000..0f995193
--- /dev/null
+++ b/src/java/com/libmailcore/AbstractMessage.java
@@ -0,0 +1,14 @@
+package com.libmailcore;
+
+import java.util.List;
+
+public class AbstractMessage extends NativeObject {
+    public native MessageHeader header();
+    public native void setHeader(MessageHeader header);
+    
+    public native AbstractPart partForContentID(String contentID);
+    public native AbstractPart partForUniqueID(String uniqueID);
+    public native List<AbstractPart> attachments();
+    public native List<AbstractPart> htmlInlineAttachments();
+    public native List<AbstractPart> requiredPartsForRendering();
+}
diff --git a/src/java/com/libmailcore/AbstractMessagePart.java b/src/java/com/libmailcore/AbstractMessagePart.java
new file mode 100644
index 00000000..307e700c
--- /dev/null
+++ b/src/java/com/libmailcore/AbstractMessagePart.java
@@ -0,0 +1,9 @@
+package com.libmailcore;
+
+public class AbstractMessagePart extends AbstractPart {
+    public native MessageHeader header();
+    public native void setHeader(MessageHeader header);
+    
+    public native AbstractPart mainPart();    
+    public native void setMainPart(AbstractPart part);
+}
diff --git a/src/java/com/libmailcore/AbstractMultipart.java b/src/java/com/libmailcore/AbstractMultipart.java
new file mode 100644
index 00000000..c81d8d21
--- /dev/null
+++ b/src/java/com/libmailcore/AbstractMultipart.java
@@ -0,0 +1,8 @@
+package com.libmailcore;
+
+import java.util.List;
+
+public class AbstractMultipart extends AbstractPart {
+    public native List<AbstractPart> parts();
+    public native void setParts(List<AbstractPart> parts);
+}
diff --git a/src/java/com/libmailcore/AbstractPart.java b/src/java/com/libmailcore/AbstractPart.java
new file mode 100644
index 00000000..6ffbc746
--- /dev/null
+++ b/src/java/com/libmailcore/AbstractPart.java
@@ -0,0 +1,36 @@
+package com.libmailcore;
+
+import java.util.AbstractList;
+
+public class AbstractPart extends NativeObject {
+    public native int partType();
+    public native void setPartType(int partType);
+    
+    public native String filename();
+    public native void setFilename(String filename);
+    
+    public native String charset();
+    public native void setCharset(String charset);
+    
+    public native String uniqueID();
+    public native void setUniqueID(String uniqueID);
+    
+    public native String contentID();
+    public native void setContentID(String contentID);
+    
+    public native String contentLocation();
+    public native void setContentLocation(String contentLocation);
+    
+    public native String contentDescription();
+    public native void setContentDescription(String contentDescription);
+    
+    public native boolean isInlineAttachment();
+    public native void setInlineAttachment(boolean inlineAttachment);
+    
+    public native AbstractPart partForContentID(String contentID);
+    public native AbstractPart partForUniqueID(String uniqueID);
+    
+    public native void setContentTypeParameter(String name, String value);
+    public native String contentTypeParameterValueForName(String name);
+    public native AbstractList<String> allContentTypeParametersNames();
+}
diff --git a/src/java/com/libmailcore/Address.java b/src/java/com/libmailcore/Address.java
new file mode 100644
index 00000000..81a5386b
--- /dev/null
+++ b/src/java/com/libmailcore/Address.java
@@ -0,0 +1,32 @@
+package com.libmailcore;
+
+import java.util.List;
+
+public class Address extends NativeObject {
+    public native static Address addressWithDisplayName(String displayName, String mailbox);
+    public native static Address addressWithMailbox(String mailbox);
+    public native static Address addressWithRFC822String(String rfc822String);
+    public native static Address addressWithNonEncodedRFC822String(String nonEncodedRFC822String);
+    
+    public native static List<Address> addressesWithRFC822String(String rfc822String);
+    public native static List<Address> addressesWithNonEncodedRFC822String(String nonEncodedRFC822String);
+    
+    public native static String RFC822StringForAddresses(List<Address> addresses);
+    public native static String nonEncodedRFC822StringForAddresses(List<Address> addresses);
+    
+    public Address()
+    {
+        setupNative();
+    }
+    
+    public native String displayName();
+    public native void setDisplayName(String displayName);
+    
+    public native String mailbox();
+    public native void setMailbox(String address);
+    
+    public native String RFC822String();
+    public native String nonEncodedRFC822String();
+    
+    private native void setupNative();
+}
diff --git a/src/java/com/libmailcore/Attachment.java b/src/java/com/libmailcore/Attachment.java
new file mode 100644
index 00000000..4ce03ced
--- /dev/null
+++ b/src/java/com/libmailcore/Attachment.java
@@ -0,0 +1,16 @@
+package com.libmailcore;
+
+public class Attachment extends AbstractPart {
+    public static native String mimeTypeForFilename(String filename);
+    
+    public native static Attachment attachmentWithContentsOfFile(String filename);
+    public native static Attachment attachmentWithData(String filename, byte[] data);
+    public native static Attachment attachmentWithHTMLString(String htmlString);
+    public native static Attachment attachmentWithRFC822Message(byte[] messageData);
+    public native static Attachment attachmentWithText(String text);
+    
+    public native byte[] data();
+    public native void setData(byte[] data);
+    
+    public native String decodedString();
+}
\ No newline at end of file
diff --git a/src/java/com/libmailcore/ConnectionLogType.java b/src/java/com/libmailcore/ConnectionLogType.java
new file mode 100644
index 00000000..31262889
--- /dev/null
+++ b/src/java/com/libmailcore/ConnectionLogType.java
@@ -0,0 +1,10 @@
+package com.libmailcore;
+
+public class ConnectionLogType {
+    final public static int ConnectionLogTypeReceived = 0;
+    final public static int ConnectionLogTypeSent = 1;
+    final public static int ConnectionLogTypeSentPrivate = 2;
+    final public static int ConnectionLogTypeErrorParse = 3;
+    final public static int ConnectionLogTypeErrorReceived = 4;
+    final public static int ConnectionLogTypeErrorSent = 5;
+}
diff --git a/src/java/com/libmailcore/ConnectionLogger.java b/src/java/com/libmailcore/ConnectionLogger.java
new file mode 100644
index 00000000..aa85725c
--- /dev/null
+++ b/src/java/com/libmailcore/ConnectionLogger.java
@@ -0,0 +1,5 @@
+package com.libmailcore;
+
+public interface ConnectionLogger {
+    void log(long connectionID, int type, byte[] data);
+}
diff --git a/src/java/com/libmailcore/ConnectionType.java b/src/java/com/libmailcore/ConnectionType.java
new file mode 100644
index 00000000..d5eb979b
--- /dev/null
+++ b/src/java/com/libmailcore/ConnectionType.java
@@ -0,0 +1,7 @@
+package com.libmailcore;
+
+public class ConnectionType {
+    final public static int ConnectionTypeClear = 1 << 0;
+    final public static int ConnectionTypeStartTLS = 1 << 1;
+    final public static int ConnectionTypeTLS = 1 << 2;
+}
diff --git a/src/java/com/libmailcore/Encoding.java b/src/java/com/libmailcore/Encoding.java
new file mode 100644
index 00000000..bbc469f6
--- /dev/null
+++ b/src/java/com/libmailcore/Encoding.java
@@ -0,0 +1,11 @@
+package com.libmailcore;
+
+public class Encoding {
+    final public static int Encoding7Bit = 0;
+    final public static int Encoding8Bit = 1;
+    final public static int EncodingBinary = 2;
+    final public static int EncodingBase64 = 3;
+    final public static int EncodingQuotedPrintable = 4;
+    final public static int EncodingOther = 5;
+    final public static int EncodingUUEncode = -1;
+}
diff --git a/src/java/com/libmailcore/Error.java b/src/java/com/libmailcore/Error.java
new file mode 100644
index 00000000..b0c4fc40
--- /dev/null
+++ b/src/java/com/libmailcore/Error.java
@@ -0,0 +1,46 @@
+package com.libmailcore;
+
+public class Error {
+    public final static int ErrorNone = 0; // 0
+    public final static int ErrorConnection = 1;
+    public final static int ErrorTLSNotAvailable = 2;
+    public final static int ErrorParse = 3;
+    public final static int ErrorCertificate = 4;
+    public final static int ErrorAuthentication = 5;
+    public final static int ErrorGmailIMAPNotEnabled = 6;
+    public final static int ErrorGmailExceededBandwidthLimit = 7;
+    public final static int ErrorGmailTooManySimultaneousConnections = 8;
+    public final static int ErrorMobileMeMoved = 9;
+    public final static int ErrorYahooUnavailable = 10; // 10
+    public final static int ErrorNonExistantFolder = 11;
+    public final static int ErrorRename = 12;
+    public final static int ErrorDelete = 13;
+    public final static int ErrorCreate = 14;
+    public final static int ErrorSubscribe = 15;
+    public final static int ErrorAppend = 16;
+    public final static int ErrorCopy = 17;
+    public final static int ErrorExpunge = 18;
+    public final static int ErrorFetch = 19;
+    public final static int ErrorIdle = 20; // 20
+    public final static int ErrorIdentity = 21;
+    public final static int ErrorNamespace = 22;
+    public final static int ErrorStore = 23;
+    public final static int ErrorCapability = 24;
+    public final static int ErrorStartTLSNotAvailable = 25;
+    public final static int ErrorSendMessageIllegalAttachment = 26;
+    public final static int ErrorStorageLimit = 27;
+    public final static int ErrorSendMessageNotAllowed = 28;
+    public final static int ErrorNeedsConnectToWebmail = 29;
+    public final static int ErrorSendMessage = 30; // 30
+    public final static int ErrorAuthenticationRequired = 31;
+    public final static int ErrorFetchMessageList = 32;
+    public final static int ErrorDeleteMessage = 33;
+    public final static int ErrorInvalidAccount = 34;
+    public final static int ErrorFile = 35;
+    public final static int ErrorCompression = 36;
+    public final static int ErrorNoSender = 37;
+    public final static int ErrorNoRecipient = 38;
+    public final static int ErrorNoop = 39;
+    public final static int ErrorGmailApplicationSpecificPasswordRequired = 40; // 40
+    public final static int ErrorServerDate = 41;
+}
diff --git a/src/java/com/libmailcore/HTMLRendererIMAPCallback.java b/src/java/com/libmailcore/HTMLRendererIMAPCallback.java
new file mode 100644
index 00000000..35b8c27a
--- /dev/null
+++ b/src/java/com/libmailcore/HTMLRendererIMAPCallback.java
@@ -0,0 +1,7 @@
+package com.libmailcore;
+
+public interface HTMLRendererIMAPCallback {
+    byte[] dataForIMAPPart(String folder, IMAPPart part);
+    void prefetchAttachmentIMAPPart(String folder, IMAPPart part);
+    void prefetchImageIMAPPart(String folder, IMAPPart part);
+}
diff --git a/src/java/com/libmailcore/HTMLRendererTemplateCallback.java b/src/java/com/libmailcore/HTMLRendererTemplateCallback.java
new file mode 100644
index 00000000..9e98586c
--- /dev/null
+++ b/src/java/com/libmailcore/HTMLRendererTemplateCallback.java
@@ -0,0 +1,20 @@
+package com.libmailcore;
+
+import java.util.Map;
+
+public interface HTMLRendererTemplateCallback {
+    boolean canPreviewPart(AbstractPart part);
+    boolean shouldShowPart(AbstractPart part);
+    Map<String, String> templateValuesForHeader(MessageHeader header);
+    Map<String, String> templateValuesForPart(AbstractPart part);
+    String templateForMainHeader(MessageHeader header);
+    String templateForImage(AbstractPart part);
+    String templateForAttachment(AbstractPart part);
+    String templateForMessage(AbstractMessage message);
+    String templateForEmbeddedMessage(AbstractMessagePart messagePart);
+    String templateForEmbeddedMessageHeader(MessageHeader header);
+    String templateForAttachmentSeparator();
+    String cleanHTML(String html);
+    String filterHTMLForPart(String html);
+    String filterHTMLForMessage(String html);
+}
diff --git a/src/java/com/libmailcore/HTMLRendererTemplateCallbackUtils.java b/src/java/com/libmailcore/HTMLRendererTemplateCallbackUtils.java
new file mode 100644
index 00000000..f2fece70
--- /dev/null
+++ b/src/java/com/libmailcore/HTMLRendererTemplateCallbackUtils.java
@@ -0,0 +1,20 @@
+package com.libmailcore;
+
+import java.util.Map;
+
+public class HTMLRendererTemplateCallbackUtils {
+    native static boolean canPreviewPart(AbstractPart part);
+    native static boolean shouldShowPart(AbstractPart part);
+    native static Map<String, String> templateValuesForHeader(MessageHeader header);
+    native static Map<String, String> templateValuesForPart(AbstractPart part);
+    native static String templateForMainHeader(MessageHeader header);
+    native static String templateForImage(AbstractPart part);
+    native static String templateForAttachment(AbstractPart part);
+    native static String templateForMessage(AbstractMessage message);
+    native static String templateForEmbeddedMessage(AbstractMessagePart messagePart);
+    native static String templateForEmbeddedMessageHeader(MessageHeader header);
+    native static String templateForAttachmentSeparator();
+    native static String cleanHTML(String html);
+    native static String filterHTMLForPart(String html);
+    native static String filterHTMLForMessage(String html);
+}
diff --git a/src/java/com/libmailcore/IMAPAppendMessageOperation.java b/src/java/com/libmailcore/IMAPAppendMessageOperation.java
new file mode 100644
index 00000000..1e735864
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPAppendMessageOperation.java
@@ -0,0 +1,10 @@
+package com.libmailcore;
+
+import java.util.Date;
+
+public class IMAPAppendMessageOperation extends IMAPOperation {
+    public native void setDate(Date date);
+    public native Date date();
+    
+    public native long createdUID();
+}
diff --git a/src/java/com/libmailcore/IMAPCapability.java b/src/java/com/libmailcore/IMAPCapability.java
new file mode 100644
index 00000000..0a1cf349
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPCapability.java
@@ -0,0 +1,39 @@
+package com.libmailcore;
+
+public class IMAPCapability {
+    final public static int IMAPCapabilityACL = 0;
+    final public static int IMAPCapabilityBinary = 1;
+    final public static int IMAPCapabilityCatenate = 2;
+    final public static int IMAPCapabilityChildren = 3;
+    final public static int IMAPCapabilityCompressDeflate = 4;
+    final public static int IMAPCapabilityCondstore = 5;
+    final public static int IMAPCapabilityEnable = 6;
+    final public static int IMAPCapabilityIdle = 7;
+    final public static int IMAPCapabilityId = 8;
+    final public static int IMAPCapabilityLiteralPlus = 9;
+    final public static int IMAPCapabilityMultiAppend = 10;
+    final public static int IMAPCapabilityNamespace = 11;
+    final public static int IMAPCapabilityQResync = 12;
+    final public static int IMAPCapabilityQuota = 13;
+    final public static int IMAPCapabilitySort = 14;
+    final public static int IMAPCapabilityStartTLS = 15;
+    final public static int IMAPCapabilityThreadOrderedSubject = 16;
+    final public static int IMAPCapabilityThreadReferences = 17;
+    final public static int IMAPCapabilityUIDPlus = 18;
+    final public static int IMAPCapabilityUnselect = 19;
+    final public static int IMAPCapabilityXList = 20;
+    final public static int IMAPCapabilityAuthAnonymous = 21;
+    final public static int IMAPCapabilityAuthCRAMMD5 = 22;
+    final public static int IMAPCapabilityAuthDigestMD5 = 23;
+    final public static int IMAPCapabilityAuthExternal = 24;
+    final public static int IMAPCapabilityAuthGSSAPI = 25;
+    final public static int IMAPCapabilityAuthKerberosV4 = 26;
+    final public static int IMAPCapabilityAuthLogin = 27;
+    final public static int IMAPCapabilityAuthNTLM = 28;
+    final public static int IMAPCapabilityAuthOTP = 29;
+    final public static int IMAPCapabilityAuthPlain = 30;
+    final public static int IMAPCapabilityAuthSKey = 31;
+    final public static int IMAPCapabilityAuthSRP = 32;
+    final public static int IMAPCapabilityXOAuth2 = 33;
+    final public static int IMAPCapabilityGmail = 34;
+}
diff --git a/src/java/com/libmailcore/IMAPCapabilityOperation.java b/src/java/com/libmailcore/IMAPCapabilityOperation.java
new file mode 100644
index 00000000..37c4b2a5
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPCapabilityOperation.java
@@ -0,0 +1,5 @@
+package com.libmailcore;
+
+public class IMAPCapabilityOperation extends IMAPOperation {
+    public native IndexSet capabilities();
+}
diff --git a/src/java/com/libmailcore/IMAPCopyMessagesOperation.java b/src/java/com/libmailcore/IMAPCopyMessagesOperation.java
new file mode 100644
index 00000000..76fb41aa
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPCopyMessagesOperation.java
@@ -0,0 +1,7 @@
+package com.libmailcore;
+
+import java.util.Map;
+
+public class IMAPCopyMessagesOperation extends IMAPOperation {
+    public native Map<Long,Long> uidMapping();
+}
diff --git a/src/java/com/libmailcore/IMAPFetchContentOperation.java b/src/java/com/libmailcore/IMAPFetchContentOperation.java
new file mode 100644
index 00000000..07afcc0e
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPFetchContentOperation.java
@@ -0,0 +1,28 @@
+package com.libmailcore;
+
+public class IMAPFetchContentOperation extends IMAPOperation {
+    protected void finalize() throws Throwable
+    {
+        finalizeNative();
+        super.finalize();
+    }
+    
+    public void setProgressListener(IMAPOperationProgressListener aListener)
+    {
+        listener = aListener;
+        setupNativeOperationProgressListener();
+    }
+    
+    public IMAPOperationProgressListener progressListener()
+    {
+        return listener;
+    }
+    
+    public native byte[] data();
+    
+    private native void finalizeNative();
+    
+    private IMAPOperationProgressListener listener;
+    private native void setupNativeOperationProgressListener();
+    private long nativeOperationProgressListener;
+}
diff --git a/src/java/com/libmailcore/IMAPFetchFoldersOperation.java b/src/java/com/libmailcore/IMAPFetchFoldersOperation.java
new file mode 100644
index 00000000..efccef5c
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPFetchFoldersOperation.java
@@ -0,0 +1,7 @@
+package com.libmailcore;
+
+import java.util.List;
+
+public class IMAPFetchFoldersOperation extends IMAPOperation {
+    public native List<IMAPFolder> folders();
+}
diff --git a/src/java/com/libmailcore/IMAPFetchMessagesOperation.java b/src/java/com/libmailcore/IMAPFetchMessagesOperation.java
new file mode 100644
index 00000000..daf8ae58
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPFetchMessagesOperation.java
@@ -0,0 +1,29 @@
+package com.libmailcore;
+
+import java.util.List;
+
+public class IMAPFetchMessagesOperation extends IMAPOperation {
+    protected void finalize() throws Throwable
+    {
+        finalizeNative();
+        super.finalize();
+    }
+    
+    public void setProgressListener(IMAPOperationItemProgressListener aListener) {
+        listener = aListener;
+        setupNativeOperationProgressListener();
+    }
+    
+    public IMAPOperationItemProgressListener progressListener() {
+        return listener;
+    }
+    
+    public native List<IMAPMessage> messages();
+    public native IndexSet vanishedMessages();
+    
+    private native void finalizeNative();
+    
+    private IMAPOperationItemProgressListener listener;
+    private native void setupNativeOperationProgressListener();
+    private long nativeOperationProgressListener;
+}
diff --git a/src/java/com/libmailcore/IMAPFetchNamespaceOperation.java b/src/java/com/libmailcore/IMAPFetchNamespaceOperation.java
new file mode 100644
index 00000000..a973b115
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPFetchNamespaceOperation.java
@@ -0,0 +1,7 @@
+package com.libmailcore;
+
+import java.util.Map;
+
+public class IMAPFetchNamespaceOperation extends IMAPOperation {
+    public native Map<String,IMAPNamespace> namespaces();
+}
diff --git a/src/java/com/libmailcore/IMAPFetchParsedContentOperation.java b/src/java/com/libmailcore/IMAPFetchParsedContentOperation.java
new file mode 100644
index 00000000..39b5b3ec
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPFetchParsedContentOperation.java
@@ -0,0 +1,28 @@
+package com.libmailcore;
+
+public class IMAPFetchParsedContentOperation extends IMAPOperation {
+    protected void finalize() throws Throwable
+    {
+        finalizeNative();
+        super.finalize();
+    }
+    
+    public void setProgressListener(IMAPOperationProgressListener aListener)
+    {
+        listener = aListener;
+        setupNativeOperationProgressListener();
+    }
+    
+    public IMAPOperationProgressListener progressListener()
+    {
+        return listener;
+    }
+    
+    public native MessageParser parser();
+    
+    private native void finalizeNative();
+    
+    private IMAPOperationProgressListener listener;
+    private native void setupNativeOperationProgressListener();
+    private long nativeOperationProgressListener;
+}
diff --git a/src/java/com/libmailcore/IMAPFolder.java b/src/java/com/libmailcore/IMAPFolder.java
new file mode 100644
index 00000000..948da48d
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPFolder.java
@@ -0,0 +1,19 @@
+package com.libmailcore;
+
+public class IMAPFolder extends NativeObject {
+    public IMAPFolder()
+    {
+        setupNative();
+    }
+    
+    public native void setPath(String path);
+    public native String path();
+    
+    public native void setDelimiter(char delimiter);
+    public native char delimiter();
+    
+    public native void setFlags(int flags);
+    public native int flags();
+    
+    private native void setupNative();
+}
diff --git a/src/java/com/libmailcore/IMAPFolderFlags.java b/src/java/com/libmailcore/IMAPFolderFlags.java
new file mode 100644
index 00000000..e91ad4c2
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPFolderFlags.java
@@ -0,0 +1,23 @@
+package com.libmailcore;
+
+public class IMAPFolderFlags {
+    public final static int IMAPFolderFlagNone = 0;
+    public final static int IMAPFolderFlagMarked      = 1 << 0;
+    public final static int IMAPFolderFlagUnmarked    = 1 << 1;
+    public final static int IMAPFolderFlagNoSelect    = 1 << 2;
+    public final static int IMAPFolderFlagNoInferiors = 1 << 3;
+    public final static int IMAPFolderFlagInbox       = 1 << 4;
+    public final static int IMAPFolderFlagSentMail    = 1 << 5;
+    public final static int IMAPFolderFlagStarred     = 1 << 6;
+    public final static int IMAPFolderFlagAllMail     = 1 << 7;
+    public final static int IMAPFolderFlagTrash       = 1 << 8;
+    public final static int IMAPFolderFlagDrafts      = 1 << 9;
+    public final static int IMAPFolderFlagSpam        = 1 << 10;
+    public final static int IMAPFolderFlagImportant   = 1 << 11;
+    public final static int IMAPFolderFlagArchive     = 1 << 12;
+    public final static int IMAPFolderFlagAll = IMAPFolderFlagAllMail;
+    public final static int IMAPFolderFlagJunk = IMAPFolderFlagSpam;
+    public final static int IMAPFolderFlagFlagged = IMAPFolderFlagStarred;
+    public final static int IMAPFolderFlagFolderTypeMask = IMAPFolderFlagInbox | IMAPFolderFlagSentMail | IMAPFolderFlagStarred | IMAPFolderFlagAllMail |
+        IMAPFolderFlagTrash| IMAPFolderFlagDrafts | IMAPFolderFlagSpam | IMAPFolderFlagImportant | IMAPFolderFlagArchive;
+}
diff --git a/src/java/com/libmailcore/IMAPFolderInfo.java b/src/java/com/libmailcore/IMAPFolderInfo.java
new file mode 100644
index 00000000..1ecba511
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPFolderInfo.java
@@ -0,0 +1,28 @@
+package com.libmailcore;
+
+public class IMAPFolderInfo extends NativeObject {
+    public IMAPFolderInfo()
+    {
+        setupNative();
+    }
+    
+    public native long uidNext();
+    public native void setUidNext(long uidNext);
+    
+    public native long uidValidity();
+    public native void setUidValidity(long uidValidity);
+    
+    public native long modSequenceValue();
+    public native void setModSequenceValue(long modSequenceValue);
+    
+    public native int messageCount();
+    public native void setMessageCount(int messageCount);
+    
+    public native long firstUnseenUid();
+    public native void setFirstUnseenUid(long firstUnseenUid);
+    
+    public native boolean allowsNewPermanentFlags();
+    public native void setAllowsNewPermanentFlags(boolean allowsNewPermanentFlags);
+        
+    private native void setupNative();
+}
diff --git a/src/java/com/libmailcore/IMAPFolderInfoOperation.java b/src/java/com/libmailcore/IMAPFolderInfoOperation.java
new file mode 100644
index 00000000..36d01081
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPFolderInfoOperation.java
@@ -0,0 +1,5 @@
+package com.libmailcore;
+
+public class IMAPFolderInfoOperation extends IMAPOperation {
+    public native IMAPFolderInfo info();
+}
diff --git a/src/java/com/libmailcore/IMAPFolderStatus.java b/src/java/com/libmailcore/IMAPFolderStatus.java
new file mode 100644
index 00000000..09589252
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPFolderStatus.java
@@ -0,0 +1,28 @@
+package com.libmailcore;
+
+public class IMAPFolderStatus extends NativeObject {
+    public IMAPFolderStatus()
+    {
+        setupNative();
+    }
+    
+    public native void setUnseenCount(long unseen);
+    public native long unseenCount();
+    
+    public native void setMessageCount(long messages);
+    public native long messageCount();
+    
+    public native void setRecentCount(long recent);
+    public native long recentCount();
+    
+    public native void setUidNext(long uidNext);
+    public native long uidNext();
+    
+    public native void setUidValidity(long uidValidity);
+    public native long uidValidity();
+    
+    public native void setHighestModSeqValue(long highestModSeqValue);
+    public native long highestModSeqValue();
+    
+    private native void setupNative();
+}
diff --git a/src/java/com/libmailcore/IMAPFolderStatusOperation.java b/src/java/com/libmailcore/IMAPFolderStatusOperation.java
new file mode 100644
index 00000000..3d39892f
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPFolderStatusOperation.java
@@ -0,0 +1,5 @@
+package com.libmailcore;
+
+public class IMAPFolderStatusOperation extends IMAPOperation {
+    public native IMAPFolderStatus status();
+}
diff --git a/src/java/com/libmailcore/IMAPIdentity.java b/src/java/com/libmailcore/IMAPIdentity.java
new file mode 100644
index 00000000..b8191b8b
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPIdentity.java
@@ -0,0 +1,27 @@
+package com.libmailcore;
+
+import java.util.List;
+
+public class IMAPIdentity extends NativeObject {
+    public IMAPIdentity()
+    {
+        setupNative();
+    }
+
+    public native void setVendor(String vendor);
+    public native String vendor();
+    
+    public native void setName(String name);
+    public native String name();
+    
+    public native void setVersion(String version);
+    public native String version();
+
+    public native void removeAllInfos();
+    
+    public native List<String> allInfoKeys();
+    public native String infoForKey(String key);
+    public native void setInfoForKey(String key, String value);
+    
+    private native void setupNative();
+}
diff --git a/src/java/com/libmailcore/IMAPIdentityOperation.java b/src/java/com/libmailcore/IMAPIdentityOperation.java
new file mode 100644
index 00000000..443676d7
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPIdentityOperation.java
@@ -0,0 +1,5 @@
+package com.libmailcore;
+
+public class IMAPIdentityOperation extends IMAPOperation {
+    public native IMAPIdentity serverIdentity();
+}
diff --git a/src/java/com/libmailcore/IMAPIdleOperation.java b/src/java/com/libmailcore/IMAPIdleOperation.java
new file mode 100644
index 00000000..30b43c43
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPIdleOperation.java
@@ -0,0 +1,5 @@
+package com.libmailcore;
+
+public class IMAPIdleOperation extends IMAPOperation {
+    public native void interruptIdle();
+}
diff --git a/src/java/com/libmailcore/IMAPMessage.java b/src/java/com/libmailcore/IMAPMessage.java
new file mode 100644
index 00000000..05328e79
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPMessage.java
@@ -0,0 +1,53 @@
+package com.libmailcore;
+
+import java.util.List;
+
+public class IMAPMessage extends AbstractMessage {
+    public native long sequenceNumber();
+    public native void setSequenceNumber(long sequenceNumber);
+    
+    public native long uid();
+    public native void setUid(long uid);
+    
+    public native long size();
+    public native void setSize(long size);
+    
+    public native void setFlags(int flags);
+    public native int flags();
+    
+    public native void setOriginalFlags(int flags);
+    public native int originalFlags();
+    
+    public native void setCustomFlags(List<String> customFlags);
+    public native List<String> customFlags();
+    
+    public native long modSeqValue();
+    public native void setModSeqValue(long uid);
+    
+    public native void setMainPart(AbstractPart mainPart);
+    public native AbstractPart mainPart();
+    
+    public native void setGmailLabels(List<String> labels);
+    public native List<String> gmailLabels();
+    
+    public native void setGmailMessageID(long msgID);
+    public native long gmailMessageID();
+            
+    public native void setGmailThreadID(long threadID);
+    public native long gmailThreadID();
+    
+    public native AbstractPart partForPartID(String partID);
+    
+    public native AbstractPart partForContentID(String contentID);
+    public native AbstractPart partForUniqueID(String uniqueID);
+    
+    public native String htmlRendering(String folder,
+                                   HTMLRendererIMAPCallback dataCallback,
+                                   HTMLRendererTemplateCallback htmlCallback);
+
+    public String htmlRendering(String folder,
+                                HTMLRendererIMAPCallback dataCallback)
+    {
+        return htmlRendering(folder, dataCallback, null);
+    }
+}
diff --git a/src/java/com/libmailcore/IMAPMessagePart.java b/src/java/com/libmailcore/IMAPMessagePart.java
new file mode 100644
index 00000000..e6060154
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPMessagePart.java
@@ -0,0 +1,6 @@
+package com.libmailcore;
+
+public class IMAPMessagePart extends AbstractMessagePart {
+    public native void setPartID(String partID);
+    public native String partID();
+}
diff --git a/src/java/com/libmailcore/IMAPMessageRenderingOperation.java b/src/java/com/libmailcore/IMAPMessageRenderingOperation.java
new file mode 100644
index 00000000..fe66ba04
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPMessageRenderingOperation.java
@@ -0,0 +1,5 @@
+package com.libmailcore;
+
+public class IMAPMessageRenderingOperation extends IMAPOperation {
+    public native String result();
+}
diff --git a/src/java/com/libmailcore/IMAPMultipart.java b/src/java/com/libmailcore/IMAPMultipart.java
new file mode 100644
index 00000000..79819be3
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPMultipart.java
@@ -0,0 +1,7 @@
+package com.libmailcore;
+
+public class IMAPMultipart extends AbstractMultipart {
+    public native void setPartID(String partID);
+    public native String partID();
+    private native void setupNative();
+}
diff --git a/src/java/com/libmailcore/IMAPNamespace.java b/src/java/com/libmailcore/IMAPNamespace.java
new file mode 100644
index 00000000..5658b1aa
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPNamespace.java
@@ -0,0 +1,19 @@
+package com.libmailcore;
+
+import java.util.List;
+
+public class IMAPNamespace extends NativeObject {
+    public native String mainPrefix();
+    public native char mainDelimiter();
+    
+    public native List<String> prefixes();
+    
+    public native String pathForComponents(List<String> components);
+    public native String pathForComponentsAndPrefix(List<String> components, String prefix);
+    
+    public native List<String> componentsFromPath(String path);
+    
+    public native boolean containsFolderPath(String path);
+    
+    public static native IMAPNamespace namespaceWithPrefix(String prefix, char delimiter);
+}
diff --git a/src/java/com/libmailcore/IMAPNamespaceItem.java b/src/java/com/libmailcore/IMAPNamespaceItem.java
new file mode 100644
index 00000000..e8d0bfe7
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPNamespaceItem.java
@@ -0,0 +1,17 @@
+package com.libmailcore;
+
+import java.util.List;
+
+public class IMAPNamespaceItem extends NativeObject {
+    
+    public native void setPrefix(String prefix);
+    public native String prefix();
+
+    public native void setDelimiter(char delimiter);
+    public native char delimiter();
+
+    public native String pathForComponents(List<String> components);
+    public native List<String> componentsForPath(String path);
+
+    public native boolean containsFolder(String folder);
+}
diff --git a/src/java/com/libmailcore/IMAPOperation.java b/src/java/com/libmailcore/IMAPOperation.java
new file mode 100644
index 00000000..5790ec29
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPOperation.java
@@ -0,0 +1,24 @@
+package com.libmailcore;
+
+public class IMAPOperation extends Operation {
+    public MailException exception() {
+        if (errorCode() == Error.ErrorNone) {
+            return null;
+        }
+        return new MailException(errorCode());
+    }
+
+    private native int errorCode();
+    
+    protected void callCallback()
+    {
+        if (callback != null) {
+            if (errorCode() == Error.ErrorNone) {
+                callback.succeeded();
+            }
+            else {
+                callback.failed(exception());
+            }
+        }
+    }
+}
diff --git a/src/java/com/libmailcore/IMAPOperationItemProgressListener.java b/src/java/com/libmailcore/IMAPOperationItemProgressListener.java
new file mode 100644
index 00000000..00a862ca
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPOperationItemProgressListener.java
@@ -0,0 +1,5 @@
+package com.libmailcore;
+
+public interface IMAPOperationItemProgressListener {
+    void itemProgress(long current, long maximum);
+}
diff --git a/src/java/com/libmailcore/IMAPOperationProgressListener.java b/src/java/com/libmailcore/IMAPOperationProgressListener.java
new file mode 100644
index 00000000..2754403b
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPOperationProgressListener.java
@@ -0,0 +1,5 @@
+package com.libmailcore;
+
+public interface IMAPOperationProgressListener {
+    void bodyProgress(long current, long maximum);
+}
diff --git a/src/java/com/libmailcore/IMAPPart.java b/src/java/com/libmailcore/IMAPPart.java
new file mode 100644
index 00000000..753f05a0
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPPart.java
@@ -0,0 +1,14 @@
+package com.libmailcore;
+
+public class IMAPPart extends AbstractPart {
+    public native void setPartID(String partID);
+    public native String partID();
+    
+    public native void setSize(long size);
+    public native long size();
+    
+    public native long decodedSize();
+    
+    public native void setEncoding(int encoding);
+    public native int encoding();
+}
diff --git a/src/java/com/libmailcore/IMAPQuotaOperation.java b/src/java/com/libmailcore/IMAPQuotaOperation.java
new file mode 100644
index 00000000..b5f4e03a
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPQuotaOperation.java
@@ -0,0 +1,6 @@
+package com.libmailcore;
+
+public class IMAPQuotaOperation extends IMAPOperation {
+    public native int usage();
+    public native int limit();
+}
diff --git a/src/java/com/libmailcore/IMAPSearchExpression.java b/src/java/com/libmailcore/IMAPSearchExpression.java
new file mode 100644
index 00000000..1319eb08
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPSearchExpression.java
@@ -0,0 +1,48 @@
+package com.libmailcore;
+
+import java.util.Date;
+
+public class IMAPSearchExpression extends NativeObject {
+    public IMAPSearchExpression()
+    {
+        setupNative();
+    }
+    
+    public static native IMAPSearchExpression searchAll();
+    public static native IMAPSearchExpression searchFrom(String value);
+    public static native IMAPSearchExpression searchTo(String value);
+    public static native IMAPSearchExpression searchCc(String value);
+    public static native IMAPSearchExpression searchBcc(String value);
+    public static native IMAPSearchExpression searchRecipient(String value);
+    public static native IMAPSearchExpression searchSubject(String value);
+    public static native IMAPSearchExpression searchContent(String value);
+    public static native IMAPSearchExpression searchBody(String value);
+    public static native IMAPSearchExpression searchHeader(String header, String value);
+    public static native IMAPSearchExpression searchUIDs(IndexSet uids);
+    public static native IMAPSearchExpression searchRead();
+    public static native IMAPSearchExpression searchUnread();
+    public static native IMAPSearchExpression searchFlagged();
+    public static native IMAPSearchExpression searchUnflagged();
+    public static native IMAPSearchExpression searchAnswered();
+    public static native IMAPSearchExpression searchUnanswered();
+    public static native IMAPSearchExpression searchDraft();
+    public static native IMAPSearchExpression searchUndraft();
+    public static native IMAPSearchExpression searchDeleted();
+    public static native IMAPSearchExpression searchSpam();
+    public static native IMAPSearchExpression searchBeforeDate(Date date);
+    public static native IMAPSearchExpression searchOnDate(Date date);
+    public static native IMAPSearchExpression searchSinceDate(Date date);
+    public static native IMAPSearchExpression searchBeforeReceivedDate(Date date);
+    public static native IMAPSearchExpression searchOnReceivedDate(Date date);
+    public static native IMAPSearchExpression searchSinceReceivedDate(Date date);
+    public static native IMAPSearchExpression searchSizeLarger(long size);
+    public static native IMAPSearchExpression searchSizeSmaller(long size);
+    public static native IMAPSearchExpression searchGmailThreadID(long number);
+    public static native IMAPSearchExpression searchGmailMessageID(long number);
+    public static native IMAPSearchExpression searchGmailRaw(String expr);
+    public static native IMAPSearchExpression searchAnd(IMAPSearchExpression left, IMAPSearchExpression right);
+    public static native IMAPSearchExpression searchOr(IMAPSearchExpression left, IMAPSearchExpression right);
+    public static native IMAPSearchExpression searchNot(IMAPSearchExpression notExpr);
+    
+    private native void setupNative();
+}
diff --git a/src/java/com/libmailcore/IMAPSearchKind.java b/src/java/com/libmailcore/IMAPSearchKind.java
new file mode 100644
index 00000000..fe71fdcd
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPSearchKind.java
@@ -0,0 +1,40 @@
+package com.libmailcore;
+
+public class IMAPSearchKind {
+    public final static int IMAPSearchKindAll = 0;
+    public final static int IMAPSearchKindNone = 1;
+    public final static int IMAPSearchKindFrom = 2;
+    public final static int IMAPSearchKindTo = 3;
+    public final static int IMAPSearchKindCc = 4;
+    public final static int IMAPSearchKindBcc = 5;
+    public final static int IMAPSearchKindRecipient = 6;
+    public final static int IMAPSearchKindSubject = 7;
+    public final static int IMAPSearchKindContent = 8;
+    public final static int IMAPSearchKindBody = 9;
+    public final static int IMAPSearchKindUids = 10;
+    public final static int IMAPSearchKindHeader = 11;
+    public final static int IMAPSearchKindRead = 12;
+    public final static int IMAPSearchKindUnread = 13;
+    public final static int IMAPSearchKindFlagged = 14;
+    public final static int IMAPSearchKindUnflagged = 15;
+    public final static int IMAPSearchKindAnswered = 16;
+    public final static int IMAPSearchKindUnanswered = 17;
+    public final static int IMAPSearchKindDraft = 18;
+    public final static int IMAPSearchKindUndraft = 19;
+    public final static int IMAPSearchKindDeleted = 20;
+    public final static int IMAPSearchKindSpam = 21;
+    public final static int IMAPSearchKindBeforeDate = 22;
+    public final static int IMAPSearchKindOnDate = 23;
+    public final static int IMAPSearchKindSinceDate = 24;
+    public final static int IMAPSearchKindBeforeReceivedDate = 25;
+    public final static int IMAPSearchKindOnReceivedDate = 26;
+    public final static int IMAPSearchKindSinceReceivedDate = 27;
+    public final static int IMAPSearchKindSizeLarger = 28;
+    public final static int IMAPSearchKindSizeSmaller = 29;
+    public final static int IMAPSearchKindGmailThreadID = 30;
+    public final static int IMAPSearchKindGmailMessageID = 31;
+    public final static int IMAPSearchKindGmailRaw = 32;
+    public final static int IMAPSearchKindOr = 33;
+    public final static int IMAPSearchKindAnd = 34;
+    public final static int IMAPSearchKindNot = 35;
+}
diff --git a/src/java/com/libmailcore/IMAPSearchOperation.java b/src/java/com/libmailcore/IMAPSearchOperation.java
new file mode 100644
index 00000000..2b9de495
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPSearchOperation.java
@@ -0,0 +1,5 @@
+package com.libmailcore;
+
+public class IMAPSearchOperation extends IMAPOperation {
+    public native IndexSet uids();
+}
\ No newline at end of file
diff --git a/src/java/com/libmailcore/IMAPSession.java b/src/java/com/libmailcore/IMAPSession.java
new file mode 100644
index 00000000..f3e305a4
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPSession.java
@@ -0,0 +1,193 @@
+package com.libmailcore;
+
+import java.util.List;
+
+public class IMAPSession extends NativeObject {
+    public IMAPSession()
+    {
+        setupNative();
+    }
+    
+    protected void finalize() throws Throwable
+    {
+        finalizeNative();
+        super.finalize();
+    }
+    
+    public native void setHostname(String hostname);
+    public native String hostname();
+    
+    public native void setPort(int port);
+    public native int port();
+    
+    public native void setUsername(String username);
+    public native String username();
+
+    public native void setPassword(String password);
+    public native String password();
+
+    public native void setOAuth2Token(String token);
+    public native String OAuth2Token();
+    
+    public native void setAuthType(int authType);
+    public native int authType();
+    
+    public native void setConnectionType(int connectionType);
+    public native int connectionType();
+    
+    public native void setTimeout(long seconds);
+    public native long timeout();
+    
+    public native void setCheckCertificateEnabled(boolean enabled);
+    public native boolean isCheckCertificateEnabled();
+    
+    public native void setDefaultNamespace(IMAPNamespace ns);
+    public native IMAPNamespace defaultNamespace();
+    
+    public native void setAllowsFolderConcurrentAccessEnabled(boolean enabled);
+    public native boolean allowsFolderConcurrentAccessEnabled();
+    
+    public native void setMaximumConnections(int maxConnections);
+    public native int maximumConnections();
+    
+    public void setConnectionLogger(ConnectionLogger logger)
+    {
+        connectionLogger = logger;
+        setupNativeConnectionLogger();
+    }
+    
+    public ConnectionLogger connectionLogger()
+    {
+        return connectionLogger;
+    }
+    
+    public void setOperationQueueListener(OperationQueueListener listener)
+    {
+        operationQueueListener = listener;
+        setupNativeOperationQueueListener();
+    }
+    
+    public OperationQueueListener operationQueueListener()
+    {
+        return operationQueueListener;
+    }
+    
+    public native boolean isOperationQueueRunning();
+    public native void cancelAllOperations();
+    
+    public native IMAPIdentity serverIdentity();
+    public native IMAPIdentity clientIdentity();
+    public native String gmailUserDisplayName();
+    
+    public native IMAPFolderInfoOperation folderInfoOperation(String folder);
+    public native IMAPFolderStatusOperation folderStatusOperation(String folder);
+    
+    public native IMAPFetchFoldersOperation fetchSubscribedFoldersOperation();
+    public native IMAPFetchFoldersOperation fetchAllFoldersOperation();
+    
+    public native IMAPOperation renameFolderOperation(String folder, String otherName);
+    public native IMAPOperation deleteFolderOperation(String folder);
+    public native IMAPOperation createFolderOperation(String folder);
+    
+    public native IMAPOperation subscribeFolderOperation(String folder);
+    public native IMAPOperation unsubscribeFolderOperation(String folder);
+    
+    public native IMAPAppendMessageOperation appendMessageOperation(String folder, byte[] messageData, int messageFlags, List<String> customFlags);
+    public IMAPAppendMessageOperation appendMessageOperation(String folder, byte[] messageData, int messageFlags)
+    {
+        return appendMessageOperation(folder, messageData, messageFlags, null);
+    }
+    
+    public native IMAPCopyMessagesOperation copyMessagesOperation(String folder, IndexSet uids, String destFolder);
+    
+    public native IMAPOperation expungeOperation(String folder);
+    
+    public native IMAPFetchMessagesOperation fetchMessagesByUIDOperation(String folder, int requestKind, IndexSet indexes);
+    public native  IMAPFetchMessagesOperation fetchMessagesByNumberOperation(String folder, int requestKind, IndexSet indexes);
+    public native  IMAPFetchMessagesOperation syncMessagesByUIDOperation(String folder, int requestKind, IndexSet indexes, long modSeq);
+    
+    public native IMAPFetchContentOperation fetchMessageByUIDOperation(String folder, long uid, boolean urgent);
+    public IMAPFetchContentOperation fetchMessageByUIDOperation(String folder, long uid)
+    {
+        return fetchMessageByUIDOperation(folder, uid, false);
+    }
+    
+    public native IMAPFetchContentOperation fetchMessageAttachmentByUIDOperation(String folder, long uid, String partID,
+                                                                                 int encoding, boolean urgent);
+    public IMAPFetchContentOperation fetchMessageAttachmentByUIDOperation(String folder, long uid, String partID,
+                                                                          int encoding)
+    {
+        return fetchMessageAttachmentByUIDOperation(folder, uid, partID, encoding, false);
+    }
+    
+    public native IMAPFetchContentOperation fetchMessageByNumberOperation(String folder, long number, boolean urgent);
+    public IMAPFetchContentOperation fetchMessageByNumberOperation(String folder, long number)
+    {
+        return fetchMessageByNumberOperation(folder, number, false);
+    }
+    
+    public native IMAPFetchContentOperation fetchMessageAttachmentByNumberOperation(String folder, long number, String partID,
+                                                                                    int encoding, boolean urgent);
+    public IMAPFetchContentOperation fetchMessageAttachmentByNumberOperation(String folder, long number, String partID,
+                                                                                    int encoding)
+    {
+        return fetchMessageAttachmentByNumberOperation(folder, number, partID, encoding, false);
+    }
+    
+    public native IMAPFetchParsedContentOperation fetchParsedMessageByUIDOperation(String folder, long uid, boolean urgent);
+    public IMAPFetchParsedContentOperation fetchParsedMessageByUIDOperation(String folder, long uid)
+    {
+        return fetchParsedMessageByUIDOperation(folder, uid, false);
+    }
+    
+    public native IMAPFetchParsedContentOperation fetchParsedMessageByNumberOperation(String folder, long number, boolean urgent);
+    public IMAPFetchParsedContentOperation fetchParsedMessageByNumberOperation(String folder, long number)
+    {
+        return fetchParsedMessageByNumberOperation(folder, number, false);
+    }
+
+    public native IMAPOperation storeFlagsByUIDOperation(String folder, IndexSet uids, int kind, int flags, List<String> customFlags);
+    public IMAPOperation storeFlagsByUIDOperation(String folder, IndexSet uids, int kind, int flags)
+    {
+        return storeFlagsByUIDOperation(folder, uids, kind, flags, null);
+    }
+    public native IMAPOperation storeFlagsByNumberOperation(String folder, IndexSet numbers, int kind, int flags, List<String> customFlags);
+    public IMAPOperation storeFlagsByNumberOperation(String folder, IndexSet numbers, int kind, int flags)
+    {
+        return storeFlagsByNumberOperation(folder, numbers, kind, flags, null);
+    }
+    public native IMAPOperation storeLabelsByUIDOperation(String folder, IndexSet uids, int kind, List<String> labels);
+    public native IMAPOperation storeLabelsByNumberOperation(String folder, IndexSet numbers, int kind, List<String> labels);
+    
+    public native IMAPSearchOperation searchOperation(String folder, int kind, String searchString);
+    public native IMAPSearchOperation searchOperation(String folder, IMAPSearchExpression expression);
+    
+    public native IMAPIdleOperation idleOperation(String folder, long lastKnownUID);
+    
+    public native IMAPFetchNamespaceOperation fetchNamespaceOperation();
+    
+    public native IMAPIdentityOperation identityOperation(IMAPIdentity identity);
+    
+    public native IMAPOperation connectOperation();
+    public native IMAPOperation checkAccountOperation();
+    public native IMAPOperation disconnectOperation();
+    
+    public native IMAPCapabilityOperation capabilityOperation();
+    public native IMAPQuotaOperation quotaOperation();
+    
+    public native IMAPOperation noopOperation();
+    
+    public native IMAPMessageRenderingOperation htmlRenderingOperation(IMAPMessage message, String folder);
+    public native IMAPMessageRenderingOperation htmlBodyRenderingOperation(IMAPMessage message, String folder);
+    public native IMAPMessageRenderingOperation plainTextRenderingOperation(IMAPMessage message, String folder);
+    public native IMAPMessageRenderingOperation plainTextBodyRenderingOperation(IMAPMessage message, String folder, boolean stripWhitespace);
+    
+    private native void setupNative();
+    private native void finalizeNative();
+    
+    private ConnectionLogger connectionLogger;
+    private OperationQueueListener operationQueueListener;
+    
+    private native void setupNativeOperationQueueListener();
+    private native void setupNativeConnectionLogger();
+}
\ No newline at end of file
diff --git a/src/java/com/libmailcore/IMAPStoreFlagsRequestKind.java b/src/java/com/libmailcore/IMAPStoreFlagsRequestKind.java
new file mode 100644
index 00000000..dd0a2b81
--- /dev/null
+++ b/src/java/com/libmailcore/IMAPStoreFlagsRequestKind.java
@@ -0,0 +1,7 @@
+package com.libmailcore;
+
+public class IMAPStoreFlagsRequestKind {
+    public final static int IMAPStoreFlagsRequestKindAdd = 0;
+    public final static int IMAPStoreFlagsRequestKindRemove = 1;
+    public final static int IMAPStoreFlagsRequestKindSet = 2;
+}
\ No newline at end of file
diff --git a/src/java/com/libmailcore/IndexSet.java b/src/java/com/libmailcore/IndexSet.java
new file mode 100644
index 00000000..ed48fdb1
--- /dev/null
+++ b/src/java/com/libmailcore/IndexSet.java
@@ -0,0 +1,32 @@
+package com.libmailcore;
+
+import java.util.List;
+
+public class IndexSet extends NativeObject {
+    public IndexSet() {
+        setupNative();
+    }
+    
+    public static native IndexSet indexSet();
+    public static native IndexSet indexSetWithRange(Range range);
+    public static native IndexSet indexSetWithIndex(long idx);
+    
+    public native int count();
+    public native void addIndex(long idx);
+    public native void removeIndex(long idx);
+    public native boolean containsIndex(long idx);
+    
+    public native void addRange(Range range);
+    public native void removeRange(Range range);
+    public native void intersectsRange(Range range);
+    
+    public native void addIndexSet(IndexSet indexSet);
+    public native void removeIndexSet(IndexSet indexSet);
+    public native void intersectsIndexSet(IndexSet indexSet);
+    
+    public native List<Range> allRanges();
+    public native int rangesCount();
+    public native void removeAllIndexes();
+    
+    private native void setupNative();
+}
diff --git a/src/java/com/libmailcore/MailException.java b/src/java/com/libmailcore/MailException.java
new file mode 100644
index 00000000..9c152d70
--- /dev/null
+++ b/src/java/com/libmailcore/MailException.java
@@ -0,0 +1,71 @@
+package com.libmailcore;
+
+public class MailException extends Exception {
+    public int errorCode()
+    {
+        return errorCode;
+    }
+    
+    public MailException(String message, int anErrorCode)
+    {
+        super(message);
+        errorCode = anErrorCode;
+    }
+    
+    public MailException(int anErrorCode)
+    {
+        super(messageForErrorCode(anErrorCode));
+        errorCode = anErrorCode;
+    }
+    
+    private static String messageForErrorCode(int errorCode)
+    {
+        return "Error";
+    }
+    
+    static final int ERROR_NONE = 0;
+    static final int ERROR_CONNECTION = 1;
+    static final int ERROR_TLS_NOT_AVAILABLE = 2;
+    static final int ERROR_PARSE = 3;
+    static final int ERROR_CERTIFICATE = 4;
+    static final int ERROR_AUTHENTICATION = 5;
+    static final int ERROR_GMAIL_IMAP_NOT_ENABLED = 6;
+    static final int ERROR_GMAIL_EXCEED_BANDWIDTH_LIMIT = 7;
+    static final int ERROR_GMAIL_TOO_MANY_SIMULTANEOUS_CONNECTIONS = 8;
+    static final int ERROR_MOBILEME_MOVED = 9;
+    static final int ERROR_YAHOO_UNAVAILABLE = 10;
+    static final int ERROR_NON_EXISTANT_FOLDER = 11;
+    static final int ERROR_RENAME = 12;
+    static final int ERROR_DELETE = 13;
+    static final int ERROR_CREATE = 14;
+    static final int ERROR_SUBSCRIBED = 15;
+    static final int ERROR_APPEND = 16;
+    static final int ERROR_COPY = 17;
+    static final int ERROR_EXPUNGE = 18;
+    static final int ERROR_FETCH = 19;
+    static final int ERROR_IDLE = 20;
+    static final int ERROR_IDENTITY = 21;
+    static final int ERROR_NAMESPACE = 22;
+    static final int ERROR_STORE = 23;
+    static final int ERROR_CAPABILITY = 24;
+    static final int ERROR_STARTTLS_NOT_AVAILABLE = 25;
+    static final int ERROR_SEND_MESSAGE_ILLEGAL_ATTACHMENT = 26;
+    static final int ERROR_STORAGE_LIMIT = 27;
+    static final int ERROR_SEND_MESSAGE_NOT_ALLOWED = 28;
+    static final int ERROR_NEEDS_CONNECT_TO_WEBMAIL = 29;
+    static final int ERROR_SEND_MESSAGE = 30;
+    static final int ERROR_AUTHENTICATION_REQUIRED = 31;
+    static final int ERROR_FETCH_MESSAGE_LIST = 32;
+    static final int ERROR_DELETE_MESSAGE = 33;
+    static final int ERROR_INVALID_ACCOUNT = 34;
+    static final int ERROR_FILE = 35;
+    static final int ERROR_COMPRESSION = 36;
+    static final int ERROR_NO_SENDER = 37;
+    static final int ERROR_NO_RECIPIENT = 38;
+    static final int ERROR_NOOP = 39;
+    static final int ERROR_GMAIL_APPLICATION_SPECIFIC_PASSWORD_REQUIRED = 40;
+    static final int ERROR_SERVER_DATE = 41;
+    static final int ERROR_COUNT = 42;
+    
+    private int errorCode;
+}
\ No newline at end of file
diff --git a/src/java/com/libmailcore/MainThreadUtils.java b/src/java/com/libmailcore/MainThreadUtils.java
new file mode 100644
index 00000000..00a9ead2
--- /dev/null
+++ b/src/java/com/libmailcore/MainThreadUtils.java
@@ -0,0 +1,64 @@
+package com.libmailcore;
+
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+import java.util.HashMap;
+
+public class MainThreadUtils {
+    private static volatile MainThreadUtils instance = new MainThreadUtils();
+    private Handler handler;
+    private HashMap<Long, Runnable> runnablesForIdentifiers = new HashMap<Long, Runnable>();
+    
+    static public MainThreadUtils singleton() {
+        return instance;
+    }
+
+    // private constructor
+    private MainThreadUtils() {
+        System.loadLibrary("MailCore");
+        handler = new Handler(Looper.getMainLooper());
+        setupNative();
+    }
+
+    private native void setupNative();
+
+    private native void runIdentifier(long identifier);
+    private native void runIdentifierAndNotify(long identifier);
+
+    private void runOnMainThread(final long identifier) {
+        handler.post(new Runnable() {
+            @Override
+            public void run() {
+                runIdentifier(identifier);
+            }
+        });
+    }
+
+    private void runOnMainThreadAndWait(final long identifier) {
+        handler.post(new Runnable() {
+            @Override
+            public void run() {
+                runIdentifierAndNotify(identifier);
+            }
+        });
+    }
+
+    private void runAfterDelay(final long identifier, int milliseconds) {
+        Runnable runnable = new Runnable() {
+                    @Override
+                    public void run() {
+                        runnablesForIdentifiers.remove(new Long(identifier));
+                        runIdentifier(identifier);
+                    }
+                };
+        runnablesForIdentifiers.put(new Long(identifier), runnable);
+        handler.postDelayed(runnable, milliseconds);
+    }
+    
+    private void cancelDelayedRun(final long identifier) {
+        Runnable runnable = runnablesForIdentifiers.get(new Long(identifier));
+        runnablesForIdentifiers.remove(new Long(identifier));
+        handler.removeCallbacks(runnable);
+    }
+}
diff --git a/src/java/com/libmailcore/MessageBuilder.java b/src/java/com/libmailcore/MessageBuilder.java
new file mode 100644
index 00000000..66539fc7
--- /dev/null
+++ b/src/java/com/libmailcore/MessageBuilder.java
@@ -0,0 +1,41 @@
+package com.libmailcore;
+
+import java.util.List;
+
+public class MessageBuilder extends AbstractMessage {
+    public MessageBuilder()
+    {
+        setupNative();
+    }
+
+    public native void setHTMLBody(String htmlBody);
+    public native String htmlBody();
+    
+    public native void setTextBody(String textBody);
+    public native String textBody();
+    
+    public native void setAttachments(List<Attachment> attachments);
+    public native List<AbstractPart> attachments();
+    public native void addAttachment(Attachment attachment);
+    
+    public native void setRelatedAttachments(List<Attachment> attachments);
+    public native List<Attachment> relatedAttachments();
+    public native void addRelatedAttachment(Attachment attachment);
+    
+    public native void setBoundaryPrefix(String boundaryPrefix);
+    public native String boundaryPrefix();
+    
+    public native byte[] data();
+    public native byte[] dataForEncryption();
+    
+    public native String htmlRendering(HTMLRendererTemplateCallback callback);
+    public native String htmlBodyRendering();
+    
+    public native String plainTextRendering();
+    public native String plainTextBodyRendering(boolean stripWhitespace);
+    
+    public native byte[] openPGPSignedMessageDataWithSignatureData(byte[] signature);
+    public native byte[] openPGPEncryptedMessageDataWithEncryptedData(byte[] encryptedData);
+    
+    private native void setupNative();
+}
diff --git a/src/java/com/libmailcore/MessageFlag.java b/src/java/com/libmailcore/MessageFlag.java
new file mode 100644
index 00000000..22c2ffc0
--- /dev/null
+++ b/src/java/com/libmailcore/MessageFlag.java
@@ -0,0 +1,17 @@
+package com.libmailcore;
+
+public class MessageFlag {
+        final public static int MessageFlagNone          = 0;
+        final public static int MessageFlagSeen          = 1 << 0;
+        final public static int MessageFlagAnswered      = 1 << 1;
+        final public static int MessageFlagFlagged       = 1 << 2;
+        final public static int MessageFlagDeleted       = 1 << 3;
+        final public static int MessageFlagDraft         = 1 << 4;
+        final public static int MessageFlagMDNSent       = 1 << 5;
+        final public static int MessageFlagForwarded     = 1 << 6;
+        final public static int MessageFlagSubmitPending = 1 << 7;
+        final public static int MessageFlagSubmitted     = 1 << 8;
+        final public static int MessageFlagMaskAll = MessageFlagSeen | MessageFlagAnswered | MessageFlagFlagged |
+        MessageFlagDeleted | MessageFlagDraft | MessageFlagMDNSent | MessageFlagForwarded |
+        MessageFlagSubmitPending | MessageFlagSubmitted;
+}
diff --git a/src/java/com/libmailcore/MessageHeader.java b/src/java/com/libmailcore/MessageHeader.java
new file mode 100644
index 00000000..c203a5bc
--- /dev/null
+++ b/src/java/com/libmailcore/MessageHeader.java
@@ -0,0 +1,72 @@
+package com.libmailcore;
+
+import java.util.List;
+import java.util.Date;
+
+public class MessageHeader extends NativeObject {
+    
+    public MessageHeader() {
+        setupNative();
+    }
+    
+    public MessageHeader(byte[] headersData) {
+        setupNative();
+        importHeadersData(headersData);
+    }
+    
+    public native String messageID();
+    public native void setMessageID(String messageID);
+    
+    public native boolean isMessageIDAutoGenerated();
+    
+    public native List<String> references();
+    public native void setReferences(List<String> references);
+    
+    public native List<String> inReplyTo();
+    public native void setInReplyTo(List<String> inReplyTo);
+    
+    public native Date date();
+    public native void setDate(Date date);
+    
+    public native Date receivedDate();
+    public native void setReceivedDate(Date date);
+    
+    public native Address sender();
+    public native void setSender(Address sender);
+
+    public native Address from();
+    public native void setFrom(Address from);
+    
+    public native List<Address> to();
+    public native void setTo(List<Address> to);
+
+    public native List<Address> cc();
+    public native void setCc(List<Address> cc);
+
+    public native List<Address> bcc();
+    public native void setBcc(List<Address> bcc);
+
+    public native List<Address> replyTo();
+    public native void setReplyTo(List<Address> replyTo);
+
+    public native String subject();
+    public native void setSubject(String subject);
+
+    public native String userAgent();
+    public native void setUserAgent(String userAgent);
+    
+    public native void setExtraHeader(String name, String value);
+    public native void removeExtraHeader(String name);
+    public native String extraHeaderValueForName(String name);
+    public native List<String> allExtraHeadersNames();
+    
+    public native String extractedSubject();
+    public native String partialExtractedSubject();
+    
+    public native void importHeadersData(byte[] data);
+    
+    public native MessageHeader replyHeader(boolean replyAll, List<Address> excludedRecipients);
+    public native MessageHeader forwardHeader();
+    
+    private native void setupNative();
+}
diff --git a/src/java/com/libmailcore/MessageParser.java b/src/java/com/libmailcore/MessageParser.java
new file mode 100644
index 00000000..2586a6d9
--- /dev/null
+++ b/src/java/com/libmailcore/MessageParser.java
@@ -0,0 +1,20 @@
+package com.libmailcore;
+
+public class MessageParser extends AbstractMessage {
+    public static native MessageParser messageParserWithData(byte[] messageData);
+    public static native MessageParser messageParserWithContentsOfFile(String filename);
+    
+    public native AbstractPart mainPart();
+    public native byte[] data();
+    
+    public native String htmlRendering(HTMLRendererTemplateCallback callback);
+    public String htmlRendering()
+    {
+        return htmlRendering(null);
+    }
+    public native String htmlBodyRendering();
+    public native String plainTextRendering();
+    public native String plainTextBodyRendering(boolean stripWhitespace);
+    
+    private native void setupNative(byte[] messageData);
+}
diff --git a/src/java/com/libmailcore/MessagePart.java b/src/java/com/libmailcore/MessagePart.java
new file mode 100644
index 00000000..533134e7
--- /dev/null
+++ b/src/java/com/libmailcore/MessagePart.java
@@ -0,0 +1,4 @@
+package com.libmailcore;
+
+public class MessagePart extends AbstractMessagePart {
+}
diff --git a/src/java/com/libmailcore/Multipart.java b/src/java/com/libmailcore/Multipart.java
new file mode 100644
index 00000000..5251d1b2
--- /dev/null
+++ b/src/java/com/libmailcore/Multipart.java
@@ -0,0 +1,4 @@
+package com.libmailcore;
+
+public class Multipart extends AbstractMultipart {
+}
diff --git a/src/java/com/libmailcore/NativeObject.java b/src/java/com/libmailcore/NativeObject.java
new file mode 100644
index 00000000..d90b7283
--- /dev/null
+++ b/src/java/com/libmailcore/NativeObject.java
@@ -0,0 +1,25 @@
+package com.libmailcore;
+
+import java.util.Map;
+
+public class NativeObject implements Cloneable {
+    protected void finalize() throws Throwable
+    {
+        super.finalize();
+        unsetupNative();
+    }
+
+    protected native void initWithNative(long nativeHandle);
+    private native void unsetupNative();
+    public native String toString();
+    public native Object clone() throws CloneNotSupportedException;
+    
+    protected native Map serializable();
+    public static native NativeObject objectWithSerializable(Map serializable);
+
+    private long nativeHandle;
+    
+    static {
+        MainThreadUtils.singleton();
+    }
+}
diff --git a/src/java/com/libmailcore/Operation.java b/src/java/com/libmailcore/Operation.java
new file mode 100644
index 00000000..9ea4c35d
--- /dev/null
+++ b/src/java/com/libmailcore/Operation.java
@@ -0,0 +1,23 @@
+package com.libmailcore;
+
+public class Operation extends NativeObject {
+    public native void cancel();
+    public native boolean isCancelled();
+    
+    public void start(OperationCallback aCallback)
+    {
+        callback = aCallback;
+        nativeStart();
+    }
+    
+    private native void nativeStart();
+    
+    protected void callCallback()
+    {
+        if (callback != null) {
+            callback.succeeded();
+        }
+    }
+    
+    protected OperationCallback callback;
+}
diff --git a/src/java/com/libmailcore/OperationCallback.java b/src/java/com/libmailcore/OperationCallback.java
new file mode 100644
index 00000000..3b70e5c5
--- /dev/null
+++ b/src/java/com/libmailcore/OperationCallback.java
@@ -0,0 +1,6 @@
+package com.libmailcore;
+
+public interface OperationCallback {
+    void succeeded();
+    void failed(MailException exception);
+}
diff --git a/src/java/com/libmailcore/OperationQueueListener.java b/src/java/com/libmailcore/OperationQueueListener.java
new file mode 100644
index 00000000..1e939952
--- /dev/null
+++ b/src/java/com/libmailcore/OperationQueueListener.java
@@ -0,0 +1,7 @@
+package com.libmailcore;
+
+public interface OperationQueueListener {
+    void queueStartRunning();
+    void queueStoppedRunning();
+}
+
diff --git a/src/java/com/libmailcore/PartType.java b/src/java/com/libmailcore/PartType.java
new file mode 100644
index 00000000..b9ce8fcc
--- /dev/null
+++ b/src/java/com/libmailcore/PartType.java
@@ -0,0 +1,9 @@
+package com.libmailcore;
+
+public class PartType {
+    public final static int PartTypeSingle = 0;
+    public final static int PartTypeMessage = 1;
+    public final static int PartTypeMultipartMixed = 2;
+    public final static int PartTypeMultipartRelated = 3;
+    public final static int PartTypeMultipartAlternative = 4;
+}
diff --git a/src/java/com/libmailcore/Range.java b/src/java/com/libmailcore/Range.java
new file mode 100644
index 00000000..5f2de7ec
--- /dev/null
+++ b/src/java/com/libmailcore/Range.java
@@ -0,0 +1,23 @@
+package com.libmailcore;
+
+public class Range {
+    public long location;
+    public long length;
+    
+    public Range() {}
+    public Range(long aLocation, long aLength)
+    {
+        location = aLocation;
+        length = aLength;
+    }
+    
+    public native IndexSet removeRange(Range otherRange);
+    public native IndexSet union(Range otherRange);
+    public native Range intersection(Range otherRange);
+    public native boolean hasIntersection(Range otherRange);
+    public native long leftBound();
+    public native long rightBound();
+    public native String toString();
+    
+    public static native Range rangeWithString(String rangeString);
+}
\ No newline at end of file
diff --git a/src/java/generate-headers.sh b/src/java/generate-headers.sh
new file mode 100755
index 00000000..ed273439
--- /dev/null
+++ b/src/java/generate-headers.sh
@@ -0,0 +1,19 @@
+#!/bin/bash
+ANDROID_SDK=$HOME/Android/android-sdk-macosx
+TARGET_PLATFORM=android-21
+
+echo Building Java
+javac -classpath $ANDROID_SDK/platforms/$TARGET_PLATFORM/android.jar com/libmailcore/*.java
+
+echo Creating headers
+
+cd com/libmailcore
+list="`echo com/libmailcore/*.java`"
+cd ../..
+
+for name in $list; do
+    name="`echo $name|sed -e 's/\.java//'|sed -e 's/\//\./g'`"
+    javah -d native -jni $name
+done
+
+rm com/libmailcore/*.class
diff --git a/src/java/native/com_libmailcore_AbstractMessage.cpp b/src/java/native/com_libmailcore_AbstractMessage.cpp
new file mode 100644
index 00000000..ceec521a
--- /dev/null
+++ b/src/java/native/com_libmailcore_AbstractMessage.cpp
@@ -0,0 +1,44 @@
+#include "com_libmailcore_AbstractMessage.h"
+
+#include "TypesUtils.h"
+#include "JavaHandle.h"
+#include "MCAbstractMessage.h"
+#include "MCAbstractPart.h"
+#include "MCMessageHeader.h"
+
+using namespace mailcore;
+
+#define nativeType AbstractMessage
+#define javaType nativeType
+
+MC_JAVA_SYNTHESIZE(MessageHeader, setHeader, header)
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_AbstractMessage_partForContentID
+  (JNIEnv * env, jobject obj, jstring contentID)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->partForContentID(MC_FROM_JAVA(String, contentID)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_AbstractMessage_partForUniqueID
+  (JNIEnv * env, jobject obj, jstring uniqueID)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->partForUniqueID(MC_FROM_JAVA(String, uniqueID)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_AbstractMessage_attachments
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET(attachments);
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_AbstractMessage_htmlInlineAttachments
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET(htmlInlineAttachments);
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_AbstractMessage_requiredPartsForRendering
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET(requiredPartsForRendering);
+}
diff --git a/src/java/native/com_libmailcore_AbstractMessage.h b/src/java/native/com_libmailcore_AbstractMessage.h
new file mode 100644
index 00000000..bdb17a69
--- /dev/null
+++ b/src/java/native/com_libmailcore_AbstractMessage.h
@@ -0,0 +1,69 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_AbstractMessage */
+
+#ifndef _Included_com_libmailcore_AbstractMessage
+#define _Included_com_libmailcore_AbstractMessage
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_AbstractMessage
+ * Method:    header
+ * Signature: ()Lcom/libmailcore/MessageHeader;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_AbstractMessage_header
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_AbstractMessage
+ * Method:    setHeader
+ * Signature: (Lcom/libmailcore/MessageHeader;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_AbstractMessage_setHeader
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_AbstractMessage
+ * Method:    partForContentID
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/AbstractPart;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_AbstractMessage_partForContentID
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_AbstractMessage
+ * Method:    partForUniqueID
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/AbstractPart;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_AbstractMessage_partForUniqueID
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_AbstractMessage
+ * Method:    attachments
+ * Signature: ()Ljava/util/List;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_AbstractMessage_attachments
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_AbstractMessage
+ * Method:    htmlInlineAttachments
+ * Signature: ()Ljava/util/List;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_AbstractMessage_htmlInlineAttachments
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_AbstractMessage
+ * Method:    requiredPartsForRendering
+ * Signature: ()Ljava/util/List;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_AbstractMessage_requiredPartsForRendering
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_AbstractMessagePart.cpp b/src/java/native/com_libmailcore_AbstractMessagePart.cpp
new file mode 100644
index 00000000..346a76f8
--- /dev/null
+++ b/src/java/native/com_libmailcore_AbstractMessagePart.cpp
@@ -0,0 +1,14 @@
+#include "com_libmailcore_AbstractMessagePart.h"
+
+#include "TypesUtils.h"
+#include "JavaHandle.h"
+#include "MCMessageHeader.h"
+#include "MCAbstractMessagePart.h"
+
+using namespace mailcore;
+
+#define nativeType AbstractMessagePart
+#define javaType nativeType
+
+MC_JAVA_SYNTHESIZE(MessageHeader, setHeader, header)
+MC_JAVA_SYNTHESIZE(AbstractPart, setMainPart, mainPart)
diff --git a/src/java/native/com_libmailcore_AbstractMessagePart.h b/src/java/native/com_libmailcore_AbstractMessagePart.h
new file mode 100644
index 00000000..67530cc4
--- /dev/null
+++ b/src/java/native/com_libmailcore_AbstractMessagePart.h
@@ -0,0 +1,45 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_AbstractMessagePart */
+
+#ifndef _Included_com_libmailcore_AbstractMessagePart
+#define _Included_com_libmailcore_AbstractMessagePart
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_AbstractMessagePart
+ * Method:    header
+ * Signature: ()Lcom/libmailcore/MessageHeader;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_AbstractMessagePart_header
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_AbstractMessagePart
+ * Method:    setHeader
+ * Signature: (Lcom/libmailcore/MessageHeader;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_AbstractMessagePart_setHeader
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_AbstractMessagePart
+ * Method:    mainPart
+ * Signature: ()Lcom/libmailcore/AbstractPart;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_AbstractMessagePart_mainPart
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_AbstractMessagePart
+ * Method:    setMainPart
+ * Signature: (Lcom/libmailcore/AbstractPart;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_AbstractMessagePart_setMainPart
+  (JNIEnv *, jobject, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_AbstractMultipart.cpp b/src/java/native/com_libmailcore_AbstractMultipart.cpp
new file mode 100644
index 00000000..34529a7a
--- /dev/null
+++ b/src/java/native/com_libmailcore_AbstractMultipart.cpp
@@ -0,0 +1,12 @@
+#include "com_libmailcore_AbstractMultipart.h"
+
+#include "TypesUtils.h"
+#include "JavaHandle.h"
+#include "MCAbstractMultipart.h"
+
+using namespace mailcore;
+
+#define nativeType AbstractMultipart
+#define javaType nativeType
+
+MC_JAVA_SYNTHESIZE(Array, setParts, parts)
diff --git a/src/java/native/com_libmailcore_AbstractMultipart.h b/src/java/native/com_libmailcore_AbstractMultipart.h
new file mode 100644
index 00000000..59a73c33
--- /dev/null
+++ b/src/java/native/com_libmailcore_AbstractMultipart.h
@@ -0,0 +1,29 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_AbstractMultipart */
+
+#ifndef _Included_com_libmailcore_AbstractMultipart
+#define _Included_com_libmailcore_AbstractMultipart
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_AbstractMultipart
+ * Method:    parts
+ * Signature: ()Ljava/util/List;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_AbstractMultipart_parts
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_AbstractMultipart
+ * Method:    setParts
+ * Signature: (Ljava/util/List;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_AbstractMultipart_setParts
+  (JNIEnv *, jobject, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_AbstractPart.cpp b/src/java/native/com_libmailcore_AbstractPart.cpp
new file mode 100644
index 00000000..188ab4d3
--- /dev/null
+++ b/src/java/native/com_libmailcore_AbstractPart.cpp
@@ -0,0 +1,49 @@
+#include "com_libmailcore_AbstractPart.h"
+
+#include "TypesUtils.h"
+#include "JavaHandle.h"
+#include "MCAbstractPart.h"
+
+using namespace mailcore;
+
+#define nativeType AbstractPart
+#define javaType nativeType
+
+MC_JAVA_SYNTHESIZE_SCALAR(jint, PartType, setPartType, partType)
+MC_JAVA_SYNTHESIZE_STRING(setFilename, filename)
+MC_JAVA_SYNTHESIZE_STRING(setCharset, charset)
+MC_JAVA_SYNTHESIZE_STRING(setUniqueID, uniqueID)
+MC_JAVA_SYNTHESIZE_STRING(setContentID, contentID)
+MC_JAVA_SYNTHESIZE_STRING(setContentLocation, contentLocation)
+MC_JAVA_SYNTHESIZE_STRING(setContentDescription, contentDescription)
+MC_JAVA_SYNTHESIZE_SCALAR(jboolean, bool, setInlineAttachment, isInlineAttachment)
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_AbstractPart_partForContentID
+  (JNIEnv * env, jobject obj, jstring contentID)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->partForContentID(MC_FROM_JAVA(String, contentID)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_AbstractPart_partForUniqueID
+  (JNIEnv * env, jobject obj, jstring uniqueID)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->partForUniqueID(MC_FROM_JAVA(String, uniqueID)));
+}
+
+JNIEXPORT void JNICALL Java_com_libmailcore_AbstractPart_setContentTypeParameter
+  (JNIEnv * env, jobject obj, jstring name, jstring value)
+{
+    MC_JAVA_NATIVE_INSTANCE->setContentTypeParameter(MC_FROM_JAVA(String, name), MC_FROM_JAVA(String, value));
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_AbstractPart_contentTypeParameterValueForName
+  (JNIEnv * env, jobject obj, jstring name)
+{
+    return (jstring) MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->contentTypeParameterValueForName(MC_FROM_JAVA(String, name)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_AbstractPart_allContentTypeParametersNames
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET(allContentTypeParametersNames);
+}
diff --git a/src/java/native/com_libmailcore_AbstractPart.h b/src/java/native/com_libmailcore_AbstractPart.h
new file mode 100644
index 00000000..e6c41c6a
--- /dev/null
+++ b/src/java/native/com_libmailcore_AbstractPart.h
@@ -0,0 +1,181 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_AbstractPart */
+
+#ifndef _Included_com_libmailcore_AbstractPart
+#define _Included_com_libmailcore_AbstractPart
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_AbstractPart
+ * Method:    partType
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_libmailcore_AbstractPart_partType
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_AbstractPart
+ * Method:    setPartType
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_AbstractPart_setPartType
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_libmailcore_AbstractPart
+ * Method:    filename
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_AbstractPart_filename
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_AbstractPart
+ * Method:    setFilename
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_AbstractPart_setFilename
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_AbstractPart
+ * Method:    charset
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_AbstractPart_charset
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_AbstractPart
+ * Method:    setCharset
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_AbstractPart_setCharset
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_AbstractPart
+ * Method:    uniqueID
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_AbstractPart_uniqueID
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_AbstractPart
+ * Method:    setUniqueID
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_AbstractPart_setUniqueID
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_AbstractPart
+ * Method:    contentID
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_AbstractPart_contentID
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_AbstractPart
+ * Method:    setContentID
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_AbstractPart_setContentID
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_AbstractPart
+ * Method:    contentLocation
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_AbstractPart_contentLocation
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_AbstractPart
+ * Method:    setContentLocation
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_AbstractPart_setContentLocation
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_AbstractPart
+ * Method:    contentDescription
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_AbstractPart_contentDescription
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_AbstractPart
+ * Method:    setContentDescription
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_AbstractPart_setContentDescription
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_AbstractPart
+ * Method:    isInlineAttachment
+ * Signature: ()Z
+ */
+JNIEXPORT jboolean JNICALL Java_com_libmailcore_AbstractPart_isInlineAttachment
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_AbstractPart
+ * Method:    setInlineAttachment
+ * Signature: (Z)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_AbstractPart_setInlineAttachment
+  (JNIEnv *, jobject, jboolean);
+
+/*
+ * Class:     com_libmailcore_AbstractPart
+ * Method:    partForContentID
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/AbstractPart;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_AbstractPart_partForContentID
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_AbstractPart
+ * Method:    partForUniqueID
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/AbstractPart;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_AbstractPart_partForUniqueID
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_AbstractPart
+ * Method:    setContentTypeParameter
+ * Signature: (Ljava/lang/String;Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_AbstractPart_setContentTypeParameter
+  (JNIEnv *, jobject, jstring, jstring);
+
+/*
+ * Class:     com_libmailcore_AbstractPart
+ * Method:    contentTypeParameterValueForName
+ * Signature: (Ljava/lang/String;)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_AbstractPart_contentTypeParameterValueForName
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_AbstractPart
+ * Method:    allContentTypeParametersNames
+ * Signature: ()Ljava/util/AbstractList;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_AbstractPart_allContentTypeParametersNames
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_Address.cpp b/src/java/native/com_libmailcore_Address.cpp
new file mode 100644
index 00000000..f1d49d48
--- /dev/null
+++ b/src/java/native/com_libmailcore_Address.cpp
@@ -0,0 +1,77 @@
+#include "com_libmailcore_Address.h"
+
+#include "TypesUtils.h"
+#include "JavaHandle.h"
+#include "MCAddress.h"
+#include "MCDefines.h"
+
+using namespace mailcore;
+
+#define nativeType Address
+#define javaType nativeType
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Address_addressWithDisplayName
+  (JNIEnv * env, jclass cls, jstring displayName, jstring mailbox)
+{
+    return MC_TO_JAVA(Address::addressWithDisplayName(MC_FROM_JAVA(String, displayName),
+        MC_FROM_JAVA(String, mailbox)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Address_addressWithMailbox
+  (JNIEnv * env, jclass cls, jstring mailbox)
+{
+    return MC_TO_JAVA(Address::addressWithMailbox(MC_FROM_JAVA(String, mailbox)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Address_addressWithRFC822String
+  (JNIEnv * env, jclass cls, jstring rfc822String)
+{
+    return MC_TO_JAVA(Address::addressWithRFC822String(MC_FROM_JAVA(String, rfc822String)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Address_addressWithNonEncodedRFC822String
+  (JNIEnv * env, jclass cls, jstring rfc822String)
+{
+    return MC_TO_JAVA(Address::addressWithNonEncodedRFC822String(MC_FROM_JAVA(String, rfc822String)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Address_addressesWithRFC822String
+  (JNIEnv * env, jclass cls, jstring rfc822String)
+{
+    return MC_TO_JAVA(Address::addressesWithRFC822String(MC_FROM_JAVA(String, rfc822String)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Address_addressesWithNonEncodedRFC822String
+  (JNIEnv * env, jclass cls, jstring rfc822String)
+{
+    return MC_TO_JAVA(Address::addressesWithNonEncodedRFC822String(MC_FROM_JAVA(String, rfc822String)));
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_Address_RFC822StringForAddresses
+  (JNIEnv * env, jclass cls, jobject addresses)
+{
+    return (jstring) MC_TO_JAVA(Address::RFC822StringForAddresses(MC_FROM_JAVA(Array, addresses)));
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_Address_nonEncodedRFC822StringForAddresses
+  (JNIEnv * env, jclass cls, jobject addresses)
+{
+    return (jstring) MC_TO_JAVA(Address::nonEncodedRFC822StringForAddresses(MC_FROM_JAVA(Array, addresses)));
+}
+
+MC_JAVA_SYNTHESIZE_STRING(setDisplayName, displayName)
+MC_JAVA_SYNTHESIZE_STRING(setMailbox, mailbox)
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_Address_RFC822String
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET_STRING(RFC822String);
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_Address_nonEncodedRFC822String
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET_STRING(nonEncodedRFC822String);
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_Address.h b/src/java/native/com_libmailcore_Address.h
new file mode 100644
index 00000000..6bc5f042
--- /dev/null
+++ b/src/java/native/com_libmailcore_Address.h
@@ -0,0 +1,133 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_Address */
+
+#ifndef _Included_com_libmailcore_Address
+#define _Included_com_libmailcore_Address
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_Address
+ * Method:    addressWithDisplayName
+ * Signature: (Ljava/lang/String;Ljava/lang/String;)Lcom/libmailcore/Address;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Address_addressWithDisplayName
+  (JNIEnv *, jclass, jstring, jstring);
+
+/*
+ * Class:     com_libmailcore_Address
+ * Method:    addressWithMailbox
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/Address;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Address_addressWithMailbox
+  (JNIEnv *, jclass, jstring);
+
+/*
+ * Class:     com_libmailcore_Address
+ * Method:    addressWithRFC822String
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/Address;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Address_addressWithRFC822String
+  (JNIEnv *, jclass, jstring);
+
+/*
+ * Class:     com_libmailcore_Address
+ * Method:    addressWithNonEncodedRFC822String
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/Address;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Address_addressWithNonEncodedRFC822String
+  (JNIEnv *, jclass, jstring);
+
+/*
+ * Class:     com_libmailcore_Address
+ * Method:    addressesWithRFC822String
+ * Signature: (Ljava/lang/String;)Ljava/util/List;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Address_addressesWithRFC822String
+  (JNIEnv *, jclass, jstring);
+
+/*
+ * Class:     com_libmailcore_Address
+ * Method:    addressesWithNonEncodedRFC822String
+ * Signature: (Ljava/lang/String;)Ljava/util/List;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Address_addressesWithNonEncodedRFC822String
+  (JNIEnv *, jclass, jstring);
+
+/*
+ * Class:     com_libmailcore_Address
+ * Method:    RFC822StringForAddresses
+ * Signature: (Ljava/util/List;)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_Address_RFC822StringForAddresses
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     com_libmailcore_Address
+ * Method:    nonEncodedRFC822StringForAddresses
+ * Signature: (Ljava/util/List;)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_Address_nonEncodedRFC822StringForAddresses
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     com_libmailcore_Address
+ * Method:    displayName
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_Address_displayName
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_Address
+ * Method:    setDisplayName
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_Address_setDisplayName
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_Address
+ * Method:    mailbox
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_Address_mailbox
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_Address
+ * Method:    setMailbox
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_Address_setMailbox
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_Address
+ * Method:    RFC822String
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_Address_RFC822String
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_Address
+ * Method:    nonEncodedRFC822String
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_Address_nonEncodedRFC822String
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_Address
+ * Method:    setupNative
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_Address_setupNative
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_Attachment.cpp b/src/java/native/com_libmailcore_Attachment.cpp
new file mode 100644
index 00000000..652a3337
--- /dev/null
+++ b/src/java/native/com_libmailcore_Attachment.cpp
@@ -0,0 +1,57 @@
+#include "com_libmailcore_Attachment.h"
+
+#include "TypesUtils.h"
+#include "JavaHandle.h"
+#include "MCAttachment.h"
+#include "MCDefines.h"
+
+using namespace mailcore;
+
+#define nativeType Attachment
+#define javaType nativeType
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_Attachment_mimeTypeForFilename
+  (JNIEnv * env, jclass javaClass, jstring filename)
+{
+    return (jstring) MC_TO_JAVA(Attachment::mimeTypeForFilename(MC_FROM_JAVA(String, filename)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Attachment_attachmentWithContentsOfFile
+  (JNIEnv * env, jclass javaClass, jstring filename)
+{
+    return MC_TO_JAVA(Attachment::attachmentWithContentsOfFile(MC_FROM_JAVA(String, filename)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Attachment_attachmentWithData
+  (JNIEnv * env, jclass javaClass, jstring filename, jbyteArray data)
+{
+    return MC_TO_JAVA(Attachment::attachmentWithData(MC_FROM_JAVA(String, filename), MC_FROM_JAVA(Data, data)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Attachment_attachmentWithHTMLString
+  (JNIEnv * env, jclass javaClass, jstring htmlString)
+{
+    return MC_TO_JAVA(Attachment::attachmentWithHTMLString(MC_FROM_JAVA(String, htmlString)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Attachment_attachmentWithRFC822Message
+  (JNIEnv * env, jclass javaClass, jbyteArray data)
+{
+    return MC_TO_JAVA(Attachment::attachmentWithRFC822Message(MC_FROM_JAVA(Data, data)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Attachment_attachmentWithText
+  (JNIEnv * env, jclass javaClass, jstring text)
+{
+    return MC_TO_JAVA(Attachment::attachmentWithText(MC_FROM_JAVA(String, text)));
+}
+
+MC_JAVA_SYNTHESIZE_DATA(setData, data)
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_Attachment_decodedString
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET_STRING(decodedString);
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_Attachment.h b/src/java/native/com_libmailcore_Attachment.h
new file mode 100644
index 00000000..2fc98aa5
--- /dev/null
+++ b/src/java/native/com_libmailcore_Attachment.h
@@ -0,0 +1,85 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_Attachment */
+
+#ifndef _Included_com_libmailcore_Attachment
+#define _Included_com_libmailcore_Attachment
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_Attachment
+ * Method:    mimeTypeForFilename
+ * Signature: (Ljava/lang/String;)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_Attachment_mimeTypeForFilename
+  (JNIEnv *, jclass, jstring);
+
+/*
+ * Class:     com_libmailcore_Attachment
+ * Method:    attachmentWithContentsOfFile
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/Attachment;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Attachment_attachmentWithContentsOfFile
+  (JNIEnv *, jclass, jstring);
+
+/*
+ * Class:     com_libmailcore_Attachment
+ * Method:    attachmentWithData
+ * Signature: (Ljava/lang/String;[B)Lcom/libmailcore/Attachment;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Attachment_attachmentWithData
+  (JNIEnv *, jclass, jstring, jbyteArray);
+
+/*
+ * Class:     com_libmailcore_Attachment
+ * Method:    attachmentWithHTMLString
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/Attachment;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Attachment_attachmentWithHTMLString
+  (JNIEnv *, jclass, jstring);
+
+/*
+ * Class:     com_libmailcore_Attachment
+ * Method:    attachmentWithRFC822Message
+ * Signature: ([B)Lcom/libmailcore/Attachment;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Attachment_attachmentWithRFC822Message
+  (JNIEnv *, jclass, jbyteArray);
+
+/*
+ * Class:     com_libmailcore_Attachment
+ * Method:    attachmentWithText
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/Attachment;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Attachment_attachmentWithText
+  (JNIEnv *, jclass, jstring);
+
+/*
+ * Class:     com_libmailcore_Attachment
+ * Method:    data
+ * Signature: ()[B
+ */
+JNIEXPORT jbyteArray JNICALL Java_com_libmailcore_Attachment_data
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_Attachment
+ * Method:    setData
+ * Signature: ([B)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_Attachment_setData
+  (JNIEnv *, jobject, jbyteArray);
+
+/*
+ * Class:     com_libmailcore_Attachment
+ * Method:    decodedString
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_Attachment_decodedString
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_ConnectionLogType.h b/src/java/native/com_libmailcore_ConnectionLogType.h
new file mode 100644
index 00000000..be31d805
--- /dev/null
+++ b/src/java/native/com_libmailcore_ConnectionLogType.h
@@ -0,0 +1,25 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_ConnectionLogType */
+
+#ifndef _Included_com_libmailcore_ConnectionLogType
+#define _Included_com_libmailcore_ConnectionLogType
+#ifdef __cplusplus
+extern "C" {
+#endif
+#undef com_libmailcore_ConnectionLogType_ConnectionLogTypeReceived
+#define com_libmailcore_ConnectionLogType_ConnectionLogTypeReceived 0L
+#undef com_libmailcore_ConnectionLogType_ConnectionLogTypeSent
+#define com_libmailcore_ConnectionLogType_ConnectionLogTypeSent 1L
+#undef com_libmailcore_ConnectionLogType_ConnectionLogTypeSentPrivate
+#define com_libmailcore_ConnectionLogType_ConnectionLogTypeSentPrivate 2L
+#undef com_libmailcore_ConnectionLogType_ConnectionLogTypeErrorParse
+#define com_libmailcore_ConnectionLogType_ConnectionLogTypeErrorParse 3L
+#undef com_libmailcore_ConnectionLogType_ConnectionLogTypeErrorReceived
+#define com_libmailcore_ConnectionLogType_ConnectionLogTypeErrorReceived 4L
+#undef com_libmailcore_ConnectionLogType_ConnectionLogTypeErrorSent
+#define com_libmailcore_ConnectionLogType_ConnectionLogTypeErrorSent 5L
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_ConnectionLogger.h b/src/java/native/com_libmailcore_ConnectionLogger.h
new file mode 100644
index 00000000..6c46bb1d
--- /dev/null
+++ b/src/java/native/com_libmailcore_ConnectionLogger.h
@@ -0,0 +1,13 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_ConnectionLogger */
+
+#ifndef _Included_com_libmailcore_ConnectionLogger
+#define _Included_com_libmailcore_ConnectionLogger
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_ConnectionType.h b/src/java/native/com_libmailcore_ConnectionType.h
new file mode 100644
index 00000000..6b5a8c1f
--- /dev/null
+++ b/src/java/native/com_libmailcore_ConnectionType.h
@@ -0,0 +1,19 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_ConnectionType */
+
+#ifndef _Included_com_libmailcore_ConnectionType
+#define _Included_com_libmailcore_ConnectionType
+#ifdef __cplusplus
+extern "C" {
+#endif
+#undef com_libmailcore_ConnectionType_ConnectionTypeClear
+#define com_libmailcore_ConnectionType_ConnectionTypeClear 1L
+#undef com_libmailcore_ConnectionType_ConnectionTypeStartTLS
+#define com_libmailcore_ConnectionType_ConnectionTypeStartTLS 2L
+#undef com_libmailcore_ConnectionType_ConnectionTypeTLS
+#define com_libmailcore_ConnectionType_ConnectionTypeTLS 4L
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_Encoding.h b/src/java/native/com_libmailcore_Encoding.h
new file mode 100644
index 00000000..2f63c16c
--- /dev/null
+++ b/src/java/native/com_libmailcore_Encoding.h
@@ -0,0 +1,27 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_Encoding */
+
+#ifndef _Included_com_libmailcore_Encoding
+#define _Included_com_libmailcore_Encoding
+#ifdef __cplusplus
+extern "C" {
+#endif
+#undef com_libmailcore_Encoding_Encoding7Bit
+#define com_libmailcore_Encoding_Encoding7Bit 0L
+#undef com_libmailcore_Encoding_Encoding8Bit
+#define com_libmailcore_Encoding_Encoding8Bit 1L
+#undef com_libmailcore_Encoding_EncodingBinary
+#define com_libmailcore_Encoding_EncodingBinary 2L
+#undef com_libmailcore_Encoding_EncodingBase64
+#define com_libmailcore_Encoding_EncodingBase64 3L
+#undef com_libmailcore_Encoding_EncodingQuotedPrintable
+#define com_libmailcore_Encoding_EncodingQuotedPrintable 4L
+#undef com_libmailcore_Encoding_EncodingOther
+#define com_libmailcore_Encoding_EncodingOther 5L
+#undef com_libmailcore_Encoding_EncodingUUEncode
+#define com_libmailcore_Encoding_EncodingUUEncode -1L
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_Error.h b/src/java/native/com_libmailcore_Error.h
new file mode 100644
index 00000000..345b3eef
--- /dev/null
+++ b/src/java/native/com_libmailcore_Error.h
@@ -0,0 +1,97 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_Error */
+
+#ifndef _Included_com_libmailcore_Error
+#define _Included_com_libmailcore_Error
+#ifdef __cplusplus
+extern "C" {
+#endif
+#undef com_libmailcore_Error_ErrorNone
+#define com_libmailcore_Error_ErrorNone 0L
+#undef com_libmailcore_Error_ErrorConnection
+#define com_libmailcore_Error_ErrorConnection 1L
+#undef com_libmailcore_Error_ErrorTLSNotAvailable
+#define com_libmailcore_Error_ErrorTLSNotAvailable 2L
+#undef com_libmailcore_Error_ErrorParse
+#define com_libmailcore_Error_ErrorParse 3L
+#undef com_libmailcore_Error_ErrorCertificate
+#define com_libmailcore_Error_ErrorCertificate 4L
+#undef com_libmailcore_Error_ErrorAuthentication
+#define com_libmailcore_Error_ErrorAuthentication 5L
+#undef com_libmailcore_Error_ErrorGmailIMAPNotEnabled
+#define com_libmailcore_Error_ErrorGmailIMAPNotEnabled 6L
+#undef com_libmailcore_Error_ErrorGmailExceededBandwidthLimit
+#define com_libmailcore_Error_ErrorGmailExceededBandwidthLimit 7L
+#undef com_libmailcore_Error_ErrorGmailTooManySimultaneousConnections
+#define com_libmailcore_Error_ErrorGmailTooManySimultaneousConnections 8L
+#undef com_libmailcore_Error_ErrorMobileMeMoved
+#define com_libmailcore_Error_ErrorMobileMeMoved 9L
+#undef com_libmailcore_Error_ErrorYahooUnavailable
+#define com_libmailcore_Error_ErrorYahooUnavailable 10L
+#undef com_libmailcore_Error_ErrorNonExistantFolder
+#define com_libmailcore_Error_ErrorNonExistantFolder 11L
+#undef com_libmailcore_Error_ErrorRename
+#define com_libmailcore_Error_ErrorRename 12L
+#undef com_libmailcore_Error_ErrorDelete
+#define com_libmailcore_Error_ErrorDelete 13L
+#undef com_libmailcore_Error_ErrorCreate
+#define com_libmailcore_Error_ErrorCreate 14L
+#undef com_libmailcore_Error_ErrorSubscribe
+#define com_libmailcore_Error_ErrorSubscribe 15L
+#undef com_libmailcore_Error_ErrorAppend
+#define com_libmailcore_Error_ErrorAppend 16L
+#undef com_libmailcore_Error_ErrorCopy
+#define com_libmailcore_Error_ErrorCopy 17L
+#undef com_libmailcore_Error_ErrorExpunge
+#define com_libmailcore_Error_ErrorExpunge 18L
+#undef com_libmailcore_Error_ErrorFetch
+#define com_libmailcore_Error_ErrorFetch 19L
+#undef com_libmailcore_Error_ErrorIdle
+#define com_libmailcore_Error_ErrorIdle 20L
+#undef com_libmailcore_Error_ErrorIdentity
+#define com_libmailcore_Error_ErrorIdentity 21L
+#undef com_libmailcore_Error_ErrorNamespace
+#define com_libmailcore_Error_ErrorNamespace 22L
+#undef com_libmailcore_Error_ErrorStore
+#define com_libmailcore_Error_ErrorStore 23L
+#undef com_libmailcore_Error_ErrorCapability
+#define com_libmailcore_Error_ErrorCapability 24L
+#undef com_libmailcore_Error_ErrorStartTLSNotAvailable
+#define com_libmailcore_Error_ErrorStartTLSNotAvailable 25L
+#undef com_libmailcore_Error_ErrorSendMessageIllegalAttachment
+#define com_libmailcore_Error_ErrorSendMessageIllegalAttachment 26L
+#undef com_libmailcore_Error_ErrorStorageLimit
+#define com_libmailcore_Error_ErrorStorageLimit 27L
+#undef com_libmailcore_Error_ErrorSendMessageNotAllowed
+#define com_libmailcore_Error_ErrorSendMessageNotAllowed 28L
+#undef com_libmailcore_Error_ErrorNeedsConnectToWebmail
+#define com_libmailcore_Error_ErrorNeedsConnectToWebmail 29L
+#undef com_libmailcore_Error_ErrorSendMessage
+#define com_libmailcore_Error_ErrorSendMessage 30L
+#undef com_libmailcore_Error_ErrorAuthenticationRequired
+#define com_libmailcore_Error_ErrorAuthenticationRequired 31L
+#undef com_libmailcore_Error_ErrorFetchMessageList
+#define com_libmailcore_Error_ErrorFetchMessageList 32L
+#undef com_libmailcore_Error_ErrorDeleteMessage
+#define com_libmailcore_Error_ErrorDeleteMessage 33L
+#undef com_libmailcore_Error_ErrorInvalidAccount
+#define com_libmailcore_Error_ErrorInvalidAccount 34L
+#undef com_libmailcore_Error_ErrorFile
+#define com_libmailcore_Error_ErrorFile 35L
+#undef com_libmailcore_Error_ErrorCompression
+#define com_libmailcore_Error_ErrorCompression 36L
+#undef com_libmailcore_Error_ErrorNoSender
+#define com_libmailcore_Error_ErrorNoSender 37L
+#undef com_libmailcore_Error_ErrorNoRecipient
+#define com_libmailcore_Error_ErrorNoRecipient 38L
+#undef com_libmailcore_Error_ErrorNoop
+#define com_libmailcore_Error_ErrorNoop 39L
+#undef com_libmailcore_Error_ErrorGmailApplicationSpecificPasswordRequired
+#define com_libmailcore_Error_ErrorGmailApplicationSpecificPasswordRequired 40L
+#undef com_libmailcore_Error_ErrorServerDate
+#define com_libmailcore_Error_ErrorServerDate 41L
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_HTMLRendererIMAPCallback.h b/src/java/native/com_libmailcore_HTMLRendererIMAPCallback.h
new file mode 100644
index 00000000..19071bc5
--- /dev/null
+++ b/src/java/native/com_libmailcore_HTMLRendererIMAPCallback.h
@@ -0,0 +1,13 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_HTMLRendererIMAPCallback */
+
+#ifndef _Included_com_libmailcore_HTMLRendererIMAPCallback
+#define _Included_com_libmailcore_HTMLRendererIMAPCallback
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_HTMLRendererTemplateCallback.h b/src/java/native/com_libmailcore_HTMLRendererTemplateCallback.h
new file mode 100644
index 00000000..c27204e6
--- /dev/null
+++ b/src/java/native/com_libmailcore_HTMLRendererTemplateCallback.h
@@ -0,0 +1,13 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_HTMLRendererTemplateCallback */
+
+#ifndef _Included_com_libmailcore_HTMLRendererTemplateCallback
+#define _Included_com_libmailcore_HTMLRendererTemplateCallback
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_HTMLRendererTemplateCallbackUtils.cpp b/src/java/native/com_libmailcore_HTMLRendererTemplateCallbackUtils.cpp
new file mode 100644
index 00000000..9a127523
--- /dev/null
+++ b/src/java/native/com_libmailcore_HTMLRendererTemplateCallbackUtils.cpp
@@ -0,0 +1,99 @@
+#include "com_libmailcore_HTMLRendererTemplateCallbackUtils.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCHTMLRendererCallback.h"
+
+using namespace mailcore;
+
+static HTMLRendererTemplateCallback * callback = NULL;
+
+JNIEXPORT jboolean JNICALL Java_com_libmailcore_HTMLRendererTemplateCallbackUtils_canPreviewPart
+  (JNIEnv * env, jclass cls, jobject part)
+{
+    return (jboolean) callback->canPreviewPart(MC_FROM_JAVA(AbstractPart, part));
+}
+
+JNIEXPORT jboolean JNICALL Java_com_libmailcore_HTMLRendererTemplateCallbackUtils_shouldShowPart
+  (JNIEnv * env, jclass cls, jobject part)
+{
+    return (jboolean) callback->canPreviewPart(MC_FROM_JAVA(AbstractPart, part));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_HTMLRendererTemplateCallbackUtils_templateValuesForHeader
+  (JNIEnv * env, jclass cls, jobject header)
+{
+    return MC_TO_JAVA(callback->templateValuesForHeader(MC_FROM_JAVA(MessageHeader, header)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_HTMLRendererTemplateCallbackUtils_templateValuesForPart
+  (JNIEnv * env, jclass cls, jobject part)
+{
+    return MC_TO_JAVA(callback->templateValuesForPart(MC_FROM_JAVA(AbstractPart, part)));
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_HTMLRendererTemplateCallbackUtils_templateForMainHeader
+  (JNIEnv * env, jclass cls, jobject header)
+{
+    return (jstring) MC_TO_JAVA(callback->templateForMainHeader(MC_FROM_JAVA(MessageHeader, header)));
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_HTMLRendererTemplateCallbackUtils_templateForImage
+  (JNIEnv * env, jclass cls, jobject part)
+{
+    return (jstring) MC_TO_JAVA(callback->templateForImage(MC_FROM_JAVA(AbstractPart, part)));
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_HTMLRendererTemplateCallbackUtils_templateForAttachment
+  (JNIEnv * env, jclass cls, jobject part)
+{
+    return (jstring) MC_TO_JAVA(callback->templateForAttachment(MC_FROM_JAVA(AbstractPart, part)));
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_HTMLRendererTemplateCallbackUtils_templateForMessage
+  (JNIEnv * env, jclass cls, jobject msg)
+{
+    return (jstring) MC_TO_JAVA(callback->templateForMessage(MC_FROM_JAVA(AbstractMessage, msg)));
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_HTMLRendererTemplateCallbackUtils_templateForEmbeddedMessage
+  (JNIEnv * env, jclass cls, jobject msgPart)
+{
+    return (jstring) MC_TO_JAVA(callback->templateForEmbeddedMessage(MC_FROM_JAVA(AbstractMessagePart, msgPart)));
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_HTMLRendererTemplateCallbackUtils_templateForEmbeddedMessageHeader
+  (JNIEnv * env, jclass cls, jobject header)
+{
+    return (jstring) MC_TO_JAVA(callback->templateForEmbeddedMessageHeader(MC_FROM_JAVA(MessageHeader, header)));
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_HTMLRendererTemplateCallbackUtils_templateForAttachmentSeparator
+  (JNIEnv * env, jclass cls)
+{
+    return (jstring) MC_TO_JAVA(callback->templateForAttachmentSeparator());
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_HTMLRendererTemplateCallbackUtils_cleanHTML
+  (JNIEnv * env, jclass cls, jstring html)
+{
+    return (jstring) MC_TO_JAVA(callback->cleanHTMLForPart(MC_FROM_JAVA(String, html)));
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_HTMLRendererTemplateCallbackUtils_filterHTMLForPart
+  (JNIEnv * env, jclass cls, jstring html)
+{
+    return (jstring) MC_TO_JAVA(callback->filterHTMLForPart(MC_FROM_JAVA(String, html)));
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_HTMLRendererTemplateCallbackUtils_filterHTMLForMessage
+  (JNIEnv * env, jclass cls, jstring html)
+{
+    return (jstring) MC_TO_JAVA(callback->filterHTMLForMessage(MC_FROM_JAVA(String, html)));
+}
+
+INITIALIZE(Java_com_libmailcore_HTMLRendererTemplateCallbackUtils)
+{
+    callback = new HTMLRendererTemplateCallback();
+}
diff --git a/src/java/native/com_libmailcore_HTMLRendererTemplateCallbackUtils.h b/src/java/native/com_libmailcore_HTMLRendererTemplateCallbackUtils.h
new file mode 100644
index 00000000..4ff2321c
--- /dev/null
+++ b/src/java/native/com_libmailcore_HTMLRendererTemplateCallbackUtils.h
@@ -0,0 +1,125 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_HTMLRendererTemplateCallbackUtils */
+
+#ifndef _Included_com_libmailcore_HTMLRendererTemplateCallbackUtils
+#define _Included_com_libmailcore_HTMLRendererTemplateCallbackUtils
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_HTMLRendererTemplateCallbackUtils
+ * Method:    canPreviewPart
+ * Signature: (Lcom/libmailcore/AbstractPart;)Z
+ */
+JNIEXPORT jboolean JNICALL Java_com_libmailcore_HTMLRendererTemplateCallbackUtils_canPreviewPart
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     com_libmailcore_HTMLRendererTemplateCallbackUtils
+ * Method:    shouldShowPart
+ * Signature: (Lcom/libmailcore/AbstractPart;)Z
+ */
+JNIEXPORT jboolean JNICALL Java_com_libmailcore_HTMLRendererTemplateCallbackUtils_shouldShowPart
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     com_libmailcore_HTMLRendererTemplateCallbackUtils
+ * Method:    templateValuesForHeader
+ * Signature: (Lcom/libmailcore/MessageHeader;)Ljava/util/Map;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_HTMLRendererTemplateCallbackUtils_templateValuesForHeader
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     com_libmailcore_HTMLRendererTemplateCallbackUtils
+ * Method:    templateValuesForPart
+ * Signature: (Lcom/libmailcore/AbstractPart;)Ljava/util/Map;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_HTMLRendererTemplateCallbackUtils_templateValuesForPart
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     com_libmailcore_HTMLRendererTemplateCallbackUtils
+ * Method:    templateForMainHeader
+ * Signature: (Lcom/libmailcore/MessageHeader;)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_HTMLRendererTemplateCallbackUtils_templateForMainHeader
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     com_libmailcore_HTMLRendererTemplateCallbackUtils
+ * Method:    templateForImage
+ * Signature: (Lcom/libmailcore/AbstractPart;)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_HTMLRendererTemplateCallbackUtils_templateForImage
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     com_libmailcore_HTMLRendererTemplateCallbackUtils
+ * Method:    templateForAttachment
+ * Signature: (Lcom/libmailcore/AbstractPart;)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_HTMLRendererTemplateCallbackUtils_templateForAttachment
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     com_libmailcore_HTMLRendererTemplateCallbackUtils
+ * Method:    templateForMessage
+ * Signature: (Lcom/libmailcore/AbstractMessage;)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_HTMLRendererTemplateCallbackUtils_templateForMessage
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     com_libmailcore_HTMLRendererTemplateCallbackUtils
+ * Method:    templateForEmbeddedMessage
+ * Signature: (Lcom/libmailcore/AbstractMessagePart;)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_HTMLRendererTemplateCallbackUtils_templateForEmbeddedMessage
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     com_libmailcore_HTMLRendererTemplateCallbackUtils
+ * Method:    templateForEmbeddedMessageHeader
+ * Signature: (Lcom/libmailcore/MessageHeader;)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_HTMLRendererTemplateCallbackUtils_templateForEmbeddedMessageHeader
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     com_libmailcore_HTMLRendererTemplateCallbackUtils
+ * Method:    templateForAttachmentSeparator
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_HTMLRendererTemplateCallbackUtils_templateForAttachmentSeparator
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     com_libmailcore_HTMLRendererTemplateCallbackUtils
+ * Method:    cleanHTML
+ * Signature: (Ljava/lang/String;)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_HTMLRendererTemplateCallbackUtils_cleanHTML
+  (JNIEnv *, jclass, jstring);
+
+/*
+ * Class:     com_libmailcore_HTMLRendererTemplateCallbackUtils
+ * Method:    filterHTMLForPart
+ * Signature: (Ljava/lang/String;)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_HTMLRendererTemplateCallbackUtils_filterHTMLForPart
+  (JNIEnv *, jclass, jstring);
+
+/*
+ * Class:     com_libmailcore_HTMLRendererTemplateCallbackUtils
+ * Method:    filterHTMLForMessage
+ * Signature: (Ljava/lang/String;)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_HTMLRendererTemplateCallbackUtils_filterHTMLForMessage
+  (JNIEnv *, jclass, jstring);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPAppendMessageOperation.cpp b/src/java/native/com_libmailcore_IMAPAppendMessageOperation.cpp
new file mode 100644
index 00000000..c9b90874
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPAppendMessageOperation.cpp
@@ -0,0 +1,31 @@
+#include "com_libmailcore_IMAPAppendMessageOperation.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCIMAPAppendMessageOperation.h"
+
+using namespace mailcore;
+
+#define nativeType IMAPAppendMessageOperation
+#define javaType nativeType
+
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPAppendMessageOperation_setDate
+  (JNIEnv * env, jobject obj, jobject date)
+{
+    MC_JAVA_NATIVE_INSTANCE->setDate(javaDateToTime(env, date));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPAppendMessageOperation_date
+  (JNIEnv * env, jobject obj)
+{
+    return timeToJavaDate(env, MC_JAVA_NATIVE_INSTANCE->date());
+}
+
+JNIEXPORT jlong JNICALL Java_com_libmailcore_IMAPAppendMessageOperation_createdUID
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET_SCALAR(jlong, createdUID);
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IMAPAppendMessageOperation.h b/src/java/native/com_libmailcore_IMAPAppendMessageOperation.h
new file mode 100644
index 00000000..8a71fe39
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPAppendMessageOperation.h
@@ -0,0 +1,37 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPAppendMessageOperation */
+
+#ifndef _Included_com_libmailcore_IMAPAppendMessageOperation
+#define _Included_com_libmailcore_IMAPAppendMessageOperation
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IMAPAppendMessageOperation
+ * Method:    setDate
+ * Signature: (Ljava/util/Date;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPAppendMessageOperation_setDate
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPAppendMessageOperation
+ * Method:    date
+ * Signature: ()Ljava/util/Date;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPAppendMessageOperation_date
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPAppendMessageOperation
+ * Method:    createdUID
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_libmailcore_IMAPAppendMessageOperation_createdUID
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPCapability.h b/src/java/native/com_libmailcore_IMAPCapability.h
new file mode 100644
index 00000000..543f2d63
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPCapability.h
@@ -0,0 +1,83 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPCapability */
+
+#ifndef _Included_com_libmailcore_IMAPCapability
+#define _Included_com_libmailcore_IMAPCapability
+#ifdef __cplusplus
+extern "C" {
+#endif
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityACL
+#define com_libmailcore_IMAPCapability_IMAPCapabilityACL 0L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityBinary
+#define com_libmailcore_IMAPCapability_IMAPCapabilityBinary 1L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityCatenate
+#define com_libmailcore_IMAPCapability_IMAPCapabilityCatenate 2L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityChildren
+#define com_libmailcore_IMAPCapability_IMAPCapabilityChildren 3L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityCompressDeflate
+#define com_libmailcore_IMAPCapability_IMAPCapabilityCompressDeflate 4L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityCondstore
+#define com_libmailcore_IMAPCapability_IMAPCapabilityCondstore 5L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityEnable
+#define com_libmailcore_IMAPCapability_IMAPCapabilityEnable 6L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityIdle
+#define com_libmailcore_IMAPCapability_IMAPCapabilityIdle 7L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityId
+#define com_libmailcore_IMAPCapability_IMAPCapabilityId 8L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityLiteralPlus
+#define com_libmailcore_IMAPCapability_IMAPCapabilityLiteralPlus 9L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityMultiAppend
+#define com_libmailcore_IMAPCapability_IMAPCapabilityMultiAppend 10L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityNamespace
+#define com_libmailcore_IMAPCapability_IMAPCapabilityNamespace 11L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityQResync
+#define com_libmailcore_IMAPCapability_IMAPCapabilityQResync 12L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityQuota
+#define com_libmailcore_IMAPCapability_IMAPCapabilityQuota 13L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilitySort
+#define com_libmailcore_IMAPCapability_IMAPCapabilitySort 14L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityStartTLS
+#define com_libmailcore_IMAPCapability_IMAPCapabilityStartTLS 15L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityThreadOrderedSubject
+#define com_libmailcore_IMAPCapability_IMAPCapabilityThreadOrderedSubject 16L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityThreadReferences
+#define com_libmailcore_IMAPCapability_IMAPCapabilityThreadReferences 17L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityUIDPlus
+#define com_libmailcore_IMAPCapability_IMAPCapabilityUIDPlus 18L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityUnselect
+#define com_libmailcore_IMAPCapability_IMAPCapabilityUnselect 19L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityXList
+#define com_libmailcore_IMAPCapability_IMAPCapabilityXList 20L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityAuthAnonymous
+#define com_libmailcore_IMAPCapability_IMAPCapabilityAuthAnonymous 21L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityAuthCRAMMD5
+#define com_libmailcore_IMAPCapability_IMAPCapabilityAuthCRAMMD5 22L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityAuthDigestMD5
+#define com_libmailcore_IMAPCapability_IMAPCapabilityAuthDigestMD5 23L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityAuthExternal
+#define com_libmailcore_IMAPCapability_IMAPCapabilityAuthExternal 24L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityAuthGSSAPI
+#define com_libmailcore_IMAPCapability_IMAPCapabilityAuthGSSAPI 25L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityAuthKerberosV4
+#define com_libmailcore_IMAPCapability_IMAPCapabilityAuthKerberosV4 26L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityAuthLogin
+#define com_libmailcore_IMAPCapability_IMAPCapabilityAuthLogin 27L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityAuthNTLM
+#define com_libmailcore_IMAPCapability_IMAPCapabilityAuthNTLM 28L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityAuthOTP
+#define com_libmailcore_IMAPCapability_IMAPCapabilityAuthOTP 29L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityAuthPlain
+#define com_libmailcore_IMAPCapability_IMAPCapabilityAuthPlain 30L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityAuthSKey
+#define com_libmailcore_IMAPCapability_IMAPCapabilityAuthSKey 31L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityAuthSRP
+#define com_libmailcore_IMAPCapability_IMAPCapabilityAuthSRP 32L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityXOAuth2
+#define com_libmailcore_IMAPCapability_IMAPCapabilityXOAuth2 33L
+#undef com_libmailcore_IMAPCapability_IMAPCapabilityGmail
+#define com_libmailcore_IMAPCapability_IMAPCapabilityGmail 34L
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPCapabilityOperation.cpp b/src/java/native/com_libmailcore_IMAPCapabilityOperation.cpp
new file mode 100644
index 00000000..929ad9c2
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPCapabilityOperation.cpp
@@ -0,0 +1,19 @@
+#include "com_libmailcore_IMAPCapabilityOperation.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCIMAPCapabilityOperation.h"
+
+using namespace mailcore;
+
+#define nativeType IMAPCapabilityOperation
+#define javaType nativeType
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPCapabilityOperation_capabilities
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET(capabilities);
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IMAPCapabilityOperation.h b/src/java/native/com_libmailcore_IMAPCapabilityOperation.h
new file mode 100644
index 00000000..3e510561
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPCapabilityOperation.h
@@ -0,0 +1,21 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPCapabilityOperation */
+
+#ifndef _Included_com_libmailcore_IMAPCapabilityOperation
+#define _Included_com_libmailcore_IMAPCapabilityOperation
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IMAPCapabilityOperation
+ * Method:    capabilities
+ * Signature: ()Lcom/libmailcore/IndexSet;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPCapabilityOperation_capabilities
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPCopyMessagesOperation.cpp b/src/java/native/com_libmailcore_IMAPCopyMessagesOperation.cpp
new file mode 100644
index 00000000..558c7836
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPCopyMessagesOperation.cpp
@@ -0,0 +1,19 @@
+#include "com_libmailcore_IMAPCopyMessagesOperation.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCIMAPCopyMessagesOperation.h"
+
+using namespace mailcore;
+
+#define nativeType IMAPCopyMessagesOperation
+#define javaType nativeType
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPCopyMessagesOperation_uidMapping
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET(uidMapping);
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IMAPCopyMessagesOperation.h b/src/java/native/com_libmailcore_IMAPCopyMessagesOperation.h
new file mode 100644
index 00000000..46ff67de
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPCopyMessagesOperation.h
@@ -0,0 +1,21 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPCopyMessagesOperation */
+
+#ifndef _Included_com_libmailcore_IMAPCopyMessagesOperation
+#define _Included_com_libmailcore_IMAPCopyMessagesOperation
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IMAPCopyMessagesOperation
+ * Method:    uidMapping
+ * Signature: ()Ljava/util/Map;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPCopyMessagesOperation_uidMapping
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPFetchContentOperation.cpp b/src/java/native/com_libmailcore_IMAPFetchContentOperation.cpp
new file mode 100644
index 00000000..1e0cf54e
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPFetchContentOperation.cpp
@@ -0,0 +1,42 @@
+#include "com_libmailcore_IMAPFetchContentOperation.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCIMAPFetchContentOperation.h"
+#include "JavaIMAPOperationCallback.h"
+
+using namespace mailcore;
+
+#define nativeType IMAPFetchContentOperation
+#define javaType nativeType
+
+JNIEXPORT jbyteArray JNICALL Java_com_libmailcore_IMAPFetchContentOperation_data
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET_DATA(data);
+}
+
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFetchContentOperation_finalizeNative
+  (JNIEnv * env, jobject obj)
+{
+    JavaIMAPOperationCallback * callback = (JavaIMAPOperationCallback *) MC_JAVA_NATIVE_INSTANCE->imapCallback();
+    MC_SAFE_RELEASE(callback);
+    MC_JAVA_NATIVE_INSTANCE->setImapCallback(NULL);
+}
+
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFetchContentOperation_setupNativeOperationProgressListener
+  (JNIEnv * env, jobject obj)
+{
+    JavaIMAPOperationCallback * callback = (JavaIMAPOperationCallback *) MC_JAVA_NATIVE_INSTANCE->imapCallback();
+    MC_SAFE_RELEASE(callback);
+    MC_JAVA_NATIVE_INSTANCE->setImapCallback(NULL);
+
+    jobject javaListener = getObjectField(env, obj, "listener");
+    if (javaListener != NULL) {
+        callback = new JavaIMAPOperationCallback(env, javaListener);
+        MC_JAVA_NATIVE_INSTANCE->setImapCallback(callback);
+    }
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IMAPFetchContentOperation.h b/src/java/native/com_libmailcore_IMAPFetchContentOperation.h
new file mode 100644
index 00000000..5262050a
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPFetchContentOperation.h
@@ -0,0 +1,37 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPFetchContentOperation */
+
+#ifndef _Included_com_libmailcore_IMAPFetchContentOperation
+#define _Included_com_libmailcore_IMAPFetchContentOperation
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IMAPFetchContentOperation
+ * Method:    data
+ * Signature: ()[B
+ */
+JNIEXPORT jbyteArray JNICALL Java_com_libmailcore_IMAPFetchContentOperation_data
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPFetchContentOperation
+ * Method:    finalizeNative
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFetchContentOperation_finalizeNative
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPFetchContentOperation
+ * Method:    setupNativeOperationProgressListener
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFetchContentOperation_setupNativeOperationProgressListener
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPFetchFoldersOperation.cpp b/src/java/native/com_libmailcore_IMAPFetchFoldersOperation.cpp
new file mode 100644
index 00000000..50f08e2d
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPFetchFoldersOperation.cpp
@@ -0,0 +1,19 @@
+#include "com_libmailcore_IMAPFetchFoldersOperation.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCIMAPFetchFoldersOperation.h"
+
+using namespace mailcore;
+
+#define nativeType IMAPFetchFoldersOperation
+#define javaType nativeType
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPFetchFoldersOperation_folders
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET(folders);
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IMAPFetchFoldersOperation.h b/src/java/native/com_libmailcore_IMAPFetchFoldersOperation.h
new file mode 100644
index 00000000..22b72f98
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPFetchFoldersOperation.h
@@ -0,0 +1,21 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPFetchFoldersOperation */
+
+#ifndef _Included_com_libmailcore_IMAPFetchFoldersOperation
+#define _Included_com_libmailcore_IMAPFetchFoldersOperation
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IMAPFetchFoldersOperation
+ * Method:    folders
+ * Signature: ()Ljava/util/List;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPFetchFoldersOperation_folders
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPFetchMessagesOperation.cpp b/src/java/native/com_libmailcore_IMAPFetchMessagesOperation.cpp
new file mode 100644
index 00000000..735459a4
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPFetchMessagesOperation.cpp
@@ -0,0 +1,48 @@
+#include "com_libmailcore_IMAPFetchMessagesOperation.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCIMAPFetchMessagesOperation.h"
+#include "JavaIMAPOperationCallback.h"
+
+using namespace mailcore;
+
+#define nativeType IMAPFetchMessagesOperation
+#define javaType nativeType
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPFetchMessagesOperation_messages
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET(messages);
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPFetchMessagesOperation_vanishedMessages
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET(vanishedMessages);
+}
+
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFetchMessagesOperation_finalizeNative
+  (JNIEnv * env, jobject obj)
+{
+    JavaIMAPOperationCallback * callback = (JavaIMAPOperationCallback *) MC_JAVA_NATIVE_INSTANCE->imapCallback();
+    MC_SAFE_RELEASE(callback);
+    MC_JAVA_NATIVE_INSTANCE->setImapCallback(NULL);
+}
+
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFetchMessagesOperation_setupNativeOperationProgressListener
+  (JNIEnv * env, jobject obj)
+{
+    JavaIMAPOperationCallback * callback = (JavaIMAPOperationCallback *) MC_JAVA_NATIVE_INSTANCE->imapCallback();
+    MC_SAFE_RELEASE(callback);
+    MC_JAVA_NATIVE_INSTANCE->setImapCallback(NULL);
+
+    jobject javaListener = getObjectField(env, obj, "listener");
+    if (javaListener != NULL) {
+        callback = new JavaIMAPOperationCallback(env, javaListener);
+        MC_JAVA_NATIVE_INSTANCE->setImapCallback(callback);
+    }
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IMAPFetchMessagesOperation.h b/src/java/native/com_libmailcore_IMAPFetchMessagesOperation.h
new file mode 100644
index 00000000..d13cf269
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPFetchMessagesOperation.h
@@ -0,0 +1,45 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPFetchMessagesOperation */
+
+#ifndef _Included_com_libmailcore_IMAPFetchMessagesOperation
+#define _Included_com_libmailcore_IMAPFetchMessagesOperation
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IMAPFetchMessagesOperation
+ * Method:    messages
+ * Signature: ()Ljava/util/List;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPFetchMessagesOperation_messages
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPFetchMessagesOperation
+ * Method:    vanishedMessages
+ * Signature: ()Lcom/libmailcore/IndexSet;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPFetchMessagesOperation_vanishedMessages
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPFetchMessagesOperation
+ * Method:    finalizeNative
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFetchMessagesOperation_finalizeNative
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPFetchMessagesOperation
+ * Method:    setupNativeOperationProgressListener
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFetchMessagesOperation_setupNativeOperationProgressListener
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPFetchNamespaceOperation.cpp b/src/java/native/com_libmailcore_IMAPFetchNamespaceOperation.cpp
new file mode 100644
index 00000000..c2ad0091
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPFetchNamespaceOperation.cpp
@@ -0,0 +1,19 @@
+#include "com_libmailcore_IMAPFetchNamespaceOperation.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCIMAPFetchNamespaceOperation.h"
+
+using namespace mailcore;
+
+#define nativeType IMAPFetchNamespaceOperation
+#define javaType nativeType
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPFetchNamespaceOperation_namespaces
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET(namespaces);
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IMAPFetchNamespaceOperation.h b/src/java/native/com_libmailcore_IMAPFetchNamespaceOperation.h
new file mode 100644
index 00000000..bd6350e5
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPFetchNamespaceOperation.h
@@ -0,0 +1,21 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPFetchNamespaceOperation */
+
+#ifndef _Included_com_libmailcore_IMAPFetchNamespaceOperation
+#define _Included_com_libmailcore_IMAPFetchNamespaceOperation
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IMAPFetchNamespaceOperation
+ * Method:    namespaces
+ * Signature: ()Ljava/util/Map;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPFetchNamespaceOperation_namespaces
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPFetchParsedContentOperation.cpp b/src/java/native/com_libmailcore_IMAPFetchParsedContentOperation.cpp
new file mode 100644
index 00000000..662c2ca5
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPFetchParsedContentOperation.cpp
@@ -0,0 +1,42 @@
+#include "com_libmailcore_IMAPFetchParsedContentOperation.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCIMAPFetchParsedContentOperation.h"
+#include "JavaIMAPOperationCallback.h"
+
+using namespace mailcore;
+
+#define nativeType IMAPFetchParsedContentOperation
+#define javaType nativeType
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPFetchParsedContentOperation_parser
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET(parser);
+}
+
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFetchParsedContentOperation_finalizeNative
+  (JNIEnv * env, jobject obj)
+{
+    JavaIMAPOperationCallback * callback = (JavaIMAPOperationCallback *) MC_JAVA_NATIVE_INSTANCE->imapCallback();
+    MC_SAFE_RELEASE(callback);
+    MC_JAVA_NATIVE_INSTANCE->setImapCallback(NULL);
+}
+
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFetchParsedContentOperation_setupNativeOperationProgressListener
+  (JNIEnv * env, jobject obj)
+{
+    JavaIMAPOperationCallback * callback = (JavaIMAPOperationCallback *) MC_JAVA_NATIVE_INSTANCE->imapCallback();
+    MC_SAFE_RELEASE(callback);
+    MC_JAVA_NATIVE_INSTANCE->setImapCallback(NULL);
+
+    jobject javaListener = getObjectField(env, obj, "listener");
+    if (javaListener != NULL) {
+        callback = new JavaIMAPOperationCallback(env, javaListener);
+        MC_JAVA_NATIVE_INSTANCE->setImapCallback(callback);
+    }
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IMAPFetchParsedContentOperation.h b/src/java/native/com_libmailcore_IMAPFetchParsedContentOperation.h
new file mode 100644
index 00000000..d371da78
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPFetchParsedContentOperation.h
@@ -0,0 +1,37 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPFetchParsedContentOperation */
+
+#ifndef _Included_com_libmailcore_IMAPFetchParsedContentOperation
+#define _Included_com_libmailcore_IMAPFetchParsedContentOperation
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IMAPFetchParsedContentOperation
+ * Method:    parser
+ * Signature: ()Lcom/libmailcore/MessageParser;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPFetchParsedContentOperation_parser
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPFetchParsedContentOperation
+ * Method:    finalizeNative
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFetchParsedContentOperation_finalizeNative
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPFetchParsedContentOperation
+ * Method:    setupNativeOperationProgressListener
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFetchParsedContentOperation_setupNativeOperationProgressListener
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPFolder.cpp b/src/java/native/com_libmailcore_IMAPFolder.cpp
new file mode 100644
index 00000000..c14d2d7d
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPFolder.cpp
@@ -0,0 +1,17 @@
+#include "com_libmailcore_IMAPFolder.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCIMAPFolder.h"
+
+using namespace mailcore;
+
+#define nativeType IMAPFolder
+#define javaType nativeType
+
+MC_JAVA_SYNTHESIZE_STRING(setPath, path)
+MC_JAVA_SYNTHESIZE_SCALAR(jchar, char, setDelimiter, delimiter)
+MC_JAVA_SYNTHESIZE_SCALAR(jint, IMAPFolderFlag, setFlags, flags)
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IMAPFolder.h b/src/java/native/com_libmailcore_IMAPFolder.h
new file mode 100644
index 00000000..e4475662
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPFolder.h
@@ -0,0 +1,69 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPFolder */
+
+#ifndef _Included_com_libmailcore_IMAPFolder
+#define _Included_com_libmailcore_IMAPFolder
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IMAPFolder
+ * Method:    setPath
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFolder_setPath
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPFolder
+ * Method:    path
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPFolder_path
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPFolder
+ * Method:    setDelimiter
+ * Signature: (C)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFolder_setDelimiter
+  (JNIEnv *, jobject, jchar);
+
+/*
+ * Class:     com_libmailcore_IMAPFolder
+ * Method:    delimiter
+ * Signature: ()C
+ */
+JNIEXPORT jchar JNICALL Java_com_libmailcore_IMAPFolder_delimiter
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPFolder
+ * Method:    setFlags
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFolder_setFlags
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_libmailcore_IMAPFolder
+ * Method:    flags
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_libmailcore_IMAPFolder_flags
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPFolder
+ * Method:    setupNative
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFolder_setupNative
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPFolderFlags.h b/src/java/native/com_libmailcore_IMAPFolderFlags.h
new file mode 100644
index 00000000..2e7c0baf
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPFolderFlags.h
@@ -0,0 +1,49 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPFolderFlags */
+
+#ifndef _Included_com_libmailcore_IMAPFolderFlags
+#define _Included_com_libmailcore_IMAPFolderFlags
+#ifdef __cplusplus
+extern "C" {
+#endif
+#undef com_libmailcore_IMAPFolderFlags_IMAPFolderFlagNone
+#define com_libmailcore_IMAPFolderFlags_IMAPFolderFlagNone 0L
+#undef com_libmailcore_IMAPFolderFlags_IMAPFolderFlagMarked
+#define com_libmailcore_IMAPFolderFlags_IMAPFolderFlagMarked 1L
+#undef com_libmailcore_IMAPFolderFlags_IMAPFolderFlagUnmarked
+#define com_libmailcore_IMAPFolderFlags_IMAPFolderFlagUnmarked 2L
+#undef com_libmailcore_IMAPFolderFlags_IMAPFolderFlagNoSelect
+#define com_libmailcore_IMAPFolderFlags_IMAPFolderFlagNoSelect 4L
+#undef com_libmailcore_IMAPFolderFlags_IMAPFolderFlagNoInferiors
+#define com_libmailcore_IMAPFolderFlags_IMAPFolderFlagNoInferiors 8L
+#undef com_libmailcore_IMAPFolderFlags_IMAPFolderFlagInbox
+#define com_libmailcore_IMAPFolderFlags_IMAPFolderFlagInbox 16L
+#undef com_libmailcore_IMAPFolderFlags_IMAPFolderFlagSentMail
+#define com_libmailcore_IMAPFolderFlags_IMAPFolderFlagSentMail 32L
+#undef com_libmailcore_IMAPFolderFlags_IMAPFolderFlagStarred
+#define com_libmailcore_IMAPFolderFlags_IMAPFolderFlagStarred 64L
+#undef com_libmailcore_IMAPFolderFlags_IMAPFolderFlagAllMail
+#define com_libmailcore_IMAPFolderFlags_IMAPFolderFlagAllMail 128L
+#undef com_libmailcore_IMAPFolderFlags_IMAPFolderFlagTrash
+#define com_libmailcore_IMAPFolderFlags_IMAPFolderFlagTrash 256L
+#undef com_libmailcore_IMAPFolderFlags_IMAPFolderFlagDrafts
+#define com_libmailcore_IMAPFolderFlags_IMAPFolderFlagDrafts 512L
+#undef com_libmailcore_IMAPFolderFlags_IMAPFolderFlagSpam
+#define com_libmailcore_IMAPFolderFlags_IMAPFolderFlagSpam 1024L
+#undef com_libmailcore_IMAPFolderFlags_IMAPFolderFlagImportant
+#define com_libmailcore_IMAPFolderFlags_IMAPFolderFlagImportant 2048L
+#undef com_libmailcore_IMAPFolderFlags_IMAPFolderFlagArchive
+#define com_libmailcore_IMAPFolderFlags_IMAPFolderFlagArchive 4096L
+#undef com_libmailcore_IMAPFolderFlags_IMAPFolderFlagAll
+#define com_libmailcore_IMAPFolderFlags_IMAPFolderFlagAll 128L
+#undef com_libmailcore_IMAPFolderFlags_IMAPFolderFlagJunk
+#define com_libmailcore_IMAPFolderFlags_IMAPFolderFlagJunk 1024L
+#undef com_libmailcore_IMAPFolderFlags_IMAPFolderFlagFlagged
+#define com_libmailcore_IMAPFolderFlags_IMAPFolderFlagFlagged 64L
+#undef com_libmailcore_IMAPFolderFlags_IMAPFolderFlagFolderTypeMask
+#define com_libmailcore_IMAPFolderFlags_IMAPFolderFlagFolderTypeMask 8176L
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPFolderInfo.cpp b/src/java/native/com_libmailcore_IMAPFolderInfo.cpp
new file mode 100644
index 00000000..ad2fc26b
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPFolderInfo.cpp
@@ -0,0 +1,20 @@
+#include "com_libmailcore_IMAPFolderInfo.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCIMAPFolderInfo.h"
+
+using namespace mailcore;
+
+#define nativeType IMAPFolderInfo
+#define javaType nativeType
+
+MC_JAVA_SYNTHESIZE_SCALAR(jlong, uint32_t, setUidNext, uidNext)
+MC_JAVA_SYNTHESIZE_SCALAR(jlong, uint32_t, setUidValidity, uidValidity)
+MC_JAVA_SYNTHESIZE_SCALAR(jlong, uint64_t, setModSequenceValue, modSequenceValue)
+MC_JAVA_SYNTHESIZE_SCALAR(jint, int, setMessageCount, messageCount)
+MC_JAVA_SYNTHESIZE_SCALAR(jlong, uint32_t, setFirstUnseenUid, firstUnseenUid)
+MC_JAVA_SYNTHESIZE_SCALAR(jboolean, bool, setAllowsNewPermanentFlags, allowsNewPermanentFlags)
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IMAPFolderInfo.h b/src/java/native/com_libmailcore_IMAPFolderInfo.h
new file mode 100644
index 00000000..ae9d52a7
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPFolderInfo.h
@@ -0,0 +1,117 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPFolderInfo */
+
+#ifndef _Included_com_libmailcore_IMAPFolderInfo
+#define _Included_com_libmailcore_IMAPFolderInfo
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IMAPFolderInfo
+ * Method:    uidNext
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_libmailcore_IMAPFolderInfo_uidNext
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPFolderInfo
+ * Method:    setUidNext
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFolderInfo_setUidNext
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_libmailcore_IMAPFolderInfo
+ * Method:    uidValidity
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_libmailcore_IMAPFolderInfo_uidValidity
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPFolderInfo
+ * Method:    setUidValidity
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFolderInfo_setUidValidity
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_libmailcore_IMAPFolderInfo
+ * Method:    modSequenceValue
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_libmailcore_IMAPFolderInfo_modSequenceValue
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPFolderInfo
+ * Method:    setModSequenceValue
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFolderInfo_setModSequenceValue
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_libmailcore_IMAPFolderInfo
+ * Method:    messageCount
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_libmailcore_IMAPFolderInfo_messageCount
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPFolderInfo
+ * Method:    setMessageCount
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFolderInfo_setMessageCount
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_libmailcore_IMAPFolderInfo
+ * Method:    firstUnseenUid
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_libmailcore_IMAPFolderInfo_firstUnseenUid
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPFolderInfo
+ * Method:    setFirstUnseenUid
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFolderInfo_setFirstUnseenUid
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_libmailcore_IMAPFolderInfo
+ * Method:    allowsNewPermanentFlags
+ * Signature: ()Z
+ */
+JNIEXPORT jboolean JNICALL Java_com_libmailcore_IMAPFolderInfo_allowsNewPermanentFlags
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPFolderInfo
+ * Method:    setAllowsNewPermanentFlags
+ * Signature: (Z)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFolderInfo_setAllowsNewPermanentFlags
+  (JNIEnv *, jobject, jboolean);
+
+/*
+ * Class:     com_libmailcore_IMAPFolderInfo
+ * Method:    setupNative
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFolderInfo_setupNative
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPFolderInfoOperation.cpp b/src/java/native/com_libmailcore_IMAPFolderInfoOperation.cpp
new file mode 100644
index 00000000..721bdb43
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPFolderInfoOperation.cpp
@@ -0,0 +1,19 @@
+#include "com_libmailcore_IMAPFolderInfoOperation.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCIMAPFolderInfoOperation.h"
+
+using namespace mailcore;
+
+#define nativeType IMAPFolderInfoOperation
+#define javaType nativeType
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPFolderInfoOperation_info
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET(info);
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IMAPFolderInfoOperation.h b/src/java/native/com_libmailcore_IMAPFolderInfoOperation.h
new file mode 100644
index 00000000..19e432c0
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPFolderInfoOperation.h
@@ -0,0 +1,21 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPFolderInfoOperation */
+
+#ifndef _Included_com_libmailcore_IMAPFolderInfoOperation
+#define _Included_com_libmailcore_IMAPFolderInfoOperation
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IMAPFolderInfoOperation
+ * Method:    info
+ * Signature: ()Lcom/libmailcore/IMAPFolderInfo;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPFolderInfoOperation_info
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPFolderStatus.cpp b/src/java/native/com_libmailcore_IMAPFolderStatus.cpp
new file mode 100644
index 00000000..d7267063
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPFolderStatus.cpp
@@ -0,0 +1,20 @@
+#include "com_libmailcore_IMAPFolderStatus.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCIMAPFolderStatus.h"
+
+using namespace mailcore;
+
+#define nativeType IMAPFolderStatus
+#define javaType nativeType
+
+MC_JAVA_SYNTHESIZE_SCALAR(jlong, uint32_t, setUnseenCount, unseenCount)
+MC_JAVA_SYNTHESIZE_SCALAR(jlong, uint32_t, setMessageCount, messageCount)
+MC_JAVA_SYNTHESIZE_SCALAR(jlong, uint32_t, setRecentCount, recentCount)
+MC_JAVA_SYNTHESIZE_SCALAR(jlong, uint32_t, setUidNext, uidNext)
+MC_JAVA_SYNTHESIZE_SCALAR(jlong, uint32_t, setUidValidity, uidValidity)
+MC_JAVA_SYNTHESIZE_SCALAR(jlong, uint64_t, setHighestModSeqValue, highestModSeqValue)
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IMAPFolderStatus.h b/src/java/native/com_libmailcore_IMAPFolderStatus.h
new file mode 100644
index 00000000..72c70c01
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPFolderStatus.h
@@ -0,0 +1,117 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPFolderStatus */
+
+#ifndef _Included_com_libmailcore_IMAPFolderStatus
+#define _Included_com_libmailcore_IMAPFolderStatus
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IMAPFolderStatus
+ * Method:    setUnseenCount
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFolderStatus_setUnseenCount
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_libmailcore_IMAPFolderStatus
+ * Method:    unseenCount
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_libmailcore_IMAPFolderStatus_unseenCount
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPFolderStatus
+ * Method:    setMessageCount
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFolderStatus_setMessageCount
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_libmailcore_IMAPFolderStatus
+ * Method:    messageCount
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_libmailcore_IMAPFolderStatus_messageCount
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPFolderStatus
+ * Method:    setRecentCount
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFolderStatus_setRecentCount
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_libmailcore_IMAPFolderStatus
+ * Method:    recentCount
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_libmailcore_IMAPFolderStatus_recentCount
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPFolderStatus
+ * Method:    setUidNext
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFolderStatus_setUidNext
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_libmailcore_IMAPFolderStatus
+ * Method:    uidNext
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_libmailcore_IMAPFolderStatus_uidNext
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPFolderStatus
+ * Method:    setUidValidity
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFolderStatus_setUidValidity
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_libmailcore_IMAPFolderStatus
+ * Method:    uidValidity
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_libmailcore_IMAPFolderStatus_uidValidity
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPFolderStatus
+ * Method:    setHighestModSeqValue
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFolderStatus_setHighestModSeqValue
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_libmailcore_IMAPFolderStatus
+ * Method:    highestModSeqValue
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_libmailcore_IMAPFolderStatus_highestModSeqValue
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPFolderStatus
+ * Method:    setupNative
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPFolderStatus_setupNative
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPFolderStatusOperation.cpp b/src/java/native/com_libmailcore_IMAPFolderStatusOperation.cpp
new file mode 100644
index 00000000..6e9128e8
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPFolderStatusOperation.cpp
@@ -0,0 +1,19 @@
+#include "com_libmailcore_IMAPFolderStatusOperation.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCIMAPFolderStatusOperation.h"
+
+using namespace mailcore;
+
+#define nativeType IMAPFolderStatusOperation
+#define javaType nativeType
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPFolderStatusOperation_status
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET(status);
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IMAPFolderStatusOperation.h b/src/java/native/com_libmailcore_IMAPFolderStatusOperation.h
new file mode 100644
index 00000000..84641e69
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPFolderStatusOperation.h
@@ -0,0 +1,21 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPFolderStatusOperation */
+
+#ifndef _Included_com_libmailcore_IMAPFolderStatusOperation
+#define _Included_com_libmailcore_IMAPFolderStatusOperation
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IMAPFolderStatusOperation
+ * Method:    status
+ * Signature: ()Lcom/libmailcore/IMAPFolderStatus;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPFolderStatusOperation_status
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPIdentity.cpp b/src/java/native/com_libmailcore_IMAPIdentity.cpp
new file mode 100644
index 00000000..7f544b6f
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPIdentity.cpp
@@ -0,0 +1,41 @@
+#include "com_libmailcore_IMAPIdentity.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCIMAPIdentity.h"
+
+using namespace mailcore;
+
+#define nativeType IMAPIdentity
+#define javaType nativeType
+
+MC_JAVA_SYNTHESIZE_STRING(setVendor, vendor)
+MC_JAVA_SYNTHESIZE_STRING(setName, name)
+MC_JAVA_SYNTHESIZE_STRING(setVersion, version)
+
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPIdentity_removeAllInfos
+  (JNIEnv * env, jobject obj)
+{
+    MC_JAVA_NATIVE_INSTANCE->removeAllInfos();
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPIdentity_allInfoKeys
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET(allInfoKeys);
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPIdentity_infoForKey
+  (JNIEnv * env, jobject obj, jstring key)
+{
+    return (jstring) MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->infoForKey(MC_FROM_JAVA(String, key)));
+}
+
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPIdentity_setInfoForKey
+  (JNIEnv * env, jobject obj, jstring key, jstring value)
+{
+    MC_JAVA_NATIVE_INSTANCE->setInfoForKey(MC_FROM_JAVA(String, key), MC_FROM_JAVA(String, value));
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IMAPIdentity.h b/src/java/native/com_libmailcore_IMAPIdentity.h
new file mode 100644
index 00000000..e4ad1108
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPIdentity.h
@@ -0,0 +1,101 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPIdentity */
+
+#ifndef _Included_com_libmailcore_IMAPIdentity
+#define _Included_com_libmailcore_IMAPIdentity
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IMAPIdentity
+ * Method:    setVendor
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPIdentity_setVendor
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPIdentity
+ * Method:    vendor
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPIdentity_vendor
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPIdentity
+ * Method:    setName
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPIdentity_setName
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPIdentity
+ * Method:    name
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPIdentity_name
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPIdentity
+ * Method:    setVersion
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPIdentity_setVersion
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPIdentity
+ * Method:    version
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPIdentity_version
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPIdentity
+ * Method:    removeAllInfos
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPIdentity_removeAllInfos
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPIdentity
+ * Method:    allInfoKeys
+ * Signature: ()Ljava/util/List;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPIdentity_allInfoKeys
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPIdentity
+ * Method:    infoForKey
+ * Signature: (Ljava/lang/String;)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPIdentity_infoForKey
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPIdentity
+ * Method:    setInfoForKey
+ * Signature: (Ljava/lang/String;Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPIdentity_setInfoForKey
+  (JNIEnv *, jobject, jstring, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPIdentity
+ * Method:    setupNative
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPIdentity_setupNative
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPIdentityOperation.cpp b/src/java/native/com_libmailcore_IMAPIdentityOperation.cpp
new file mode 100644
index 00000000..6b033808
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPIdentityOperation.cpp
@@ -0,0 +1,19 @@
+#include "com_libmailcore_IMAPIdentityOperation.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCIMAPIdentityOperation.h"
+
+using namespace mailcore;
+
+#define nativeType IMAPIdentityOperation
+#define javaType nativeType
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPIdentityOperation_serverIdentity
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET(serverIdentity);
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IMAPIdentityOperation.h b/src/java/native/com_libmailcore_IMAPIdentityOperation.h
new file mode 100644
index 00000000..19dafc2f
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPIdentityOperation.h
@@ -0,0 +1,21 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPIdentityOperation */
+
+#ifndef _Included_com_libmailcore_IMAPIdentityOperation
+#define _Included_com_libmailcore_IMAPIdentityOperation
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IMAPIdentityOperation
+ * Method:    serverIdentity
+ * Signature: ()Lcom/libmailcore/IMAPIdentity;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPIdentityOperation_serverIdentity
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPIdleOperation.cpp b/src/java/native/com_libmailcore_IMAPIdleOperation.cpp
new file mode 100644
index 00000000..0440ae52
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPIdleOperation.cpp
@@ -0,0 +1,19 @@
+#include "com_libmailcore_IMAPIdleOperation.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCIMAPIdleOperation.h"
+
+using namespace mailcore;
+
+#define nativeType IMAPIdleOperation
+#define javaType nativeType
+
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPIdleOperation_interruptIdle
+  (JNIEnv * env, jobject obj)
+{
+    MC_JAVA_NATIVE_INSTANCE->interruptIdle();
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IMAPIdleOperation.h b/src/java/native/com_libmailcore_IMAPIdleOperation.h
new file mode 100644
index 00000000..4db3db6e
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPIdleOperation.h
@@ -0,0 +1,21 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPIdleOperation */
+
+#ifndef _Included_com_libmailcore_IMAPIdleOperation
+#define _Included_com_libmailcore_IMAPIdleOperation
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IMAPIdleOperation
+ * Method:    interruptIdle
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPIdleOperation_interruptIdle
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPMessage.cpp b/src/java/native/com_libmailcore_IMAPMessage.cpp
new file mode 100644
index 00000000..0a47efd6
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPMessage.cpp
@@ -0,0 +1,66 @@
+#include "com_libmailcore_IMAPMessage.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCIMAPMessage.h"
+#include "JavaHTMLRendererTemplateCallback.h"
+#include "JavaHTMLRendererIMAPCallback.h"
+
+using namespace mailcore;
+
+#define nativeType IMAPMessage
+#define javaType nativeType
+
+MC_JAVA_SYNTHESIZE_SCALAR(jlong, uint32_t, setSequenceNumber, sequenceNumber);
+MC_JAVA_SYNTHESIZE_SCALAR(jlong, uint32_t, setUid, uid);
+MC_JAVA_SYNTHESIZE_SCALAR(jlong, uint32_t, setSize, size);
+MC_JAVA_SYNTHESIZE_SCALAR(jint, MessageFlag, setFlags, flags);
+MC_JAVA_SYNTHESIZE_SCALAR(jint, MessageFlag, setOriginalFlags, originalFlags);
+MC_JAVA_SYNTHESIZE(Array, setCustomFlags, customFlags);
+MC_JAVA_SYNTHESIZE_SCALAR(jlong, uint64_t, setModSeqValue, modSeqValue);
+MC_JAVA_SYNTHESIZE(AbstractPart, setMainPart, mainPart);
+MC_JAVA_SYNTHESIZE(Array, setGmailLabels, gmailLabels);
+MC_JAVA_SYNTHESIZE_SCALAR(jlong, uint64_t, setGmailMessageID, gmailMessageID);
+MC_JAVA_SYNTHESIZE_SCALAR(jlong, uint64_t, setGmailThreadID, gmailThreadID);
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPMessage_partForPartID
+  (JNIEnv * env, jobject obj, jstring partID)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->partForPartID(MC_FROM_JAVA(String, partID)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPMessage_partForContentID
+  (JNIEnv * env, jobject obj, jstring contentID)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->partForContentID(MC_FROM_JAVA(String, contentID)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPMessage_partForUniqueID
+  (JNIEnv * env, jobject obj, jstring uniqueID)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->partForUniqueID(MC_FROM_JAVA(String, uniqueID)));
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPMessage_htmlRendering
+  (JNIEnv * env, jobject obj, jstring folder, jobject dataCallback, jobject htmlTemplateCallback)
+{
+    JavaHTMLRendererTemplateCallback * templateCallback = NULL;
+    if (htmlTemplateCallback != NULL) {
+        templateCallback = new JavaHTMLRendererTemplateCallback(env, htmlTemplateCallback);
+    }
+    JavaHTMLRendererIMAPCallback * imapCallback = NULL;
+    if (dataCallback != NULL) {
+        imapCallback = new JavaHTMLRendererIMAPCallback(env, dataCallback);
+    }
+    jstring result = (jstring) MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->htmlRendering(MC_FROM_JAVA(String, folder), imapCallback, templateCallback));
+    if (imapCallback != NULL) {
+        delete imapCallback;
+    }
+    if (templateCallback != NULL) {
+        delete templateCallback;
+    }
+    return result;
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IMAPMessage.h b/src/java/native/com_libmailcore_IMAPMessage.h
new file mode 100644
index 00000000..aaf287c8
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPMessage.h
@@ -0,0 +1,221 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPMessage */
+
+#ifndef _Included_com_libmailcore_IMAPMessage
+#define _Included_com_libmailcore_IMAPMessage
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IMAPMessage
+ * Method:    sequenceNumber
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_libmailcore_IMAPMessage_sequenceNumber
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPMessage
+ * Method:    setSequenceNumber
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPMessage_setSequenceNumber
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_libmailcore_IMAPMessage
+ * Method:    uid
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_libmailcore_IMAPMessage_uid
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPMessage
+ * Method:    setUid
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPMessage_setUid
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_libmailcore_IMAPMessage
+ * Method:    size
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_libmailcore_IMAPMessage_size
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPMessage
+ * Method:    setSize
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPMessage_setSize
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_libmailcore_IMAPMessage
+ * Method:    setFlags
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPMessage_setFlags
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_libmailcore_IMAPMessage
+ * Method:    flags
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_libmailcore_IMAPMessage_flags
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPMessage
+ * Method:    setOriginalFlags
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPMessage_setOriginalFlags
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_libmailcore_IMAPMessage
+ * Method:    originalFlags
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_libmailcore_IMAPMessage_originalFlags
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPMessage
+ * Method:    setCustomFlags
+ * Signature: (Ljava/util/List;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPMessage_setCustomFlags
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPMessage
+ * Method:    customFlags
+ * Signature: ()Ljava/util/List;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPMessage_customFlags
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPMessage
+ * Method:    modSeqValue
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_libmailcore_IMAPMessage_modSeqValue
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPMessage
+ * Method:    setModSeqValue
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPMessage_setModSeqValue
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_libmailcore_IMAPMessage
+ * Method:    setMainPart
+ * Signature: (Lcom/libmailcore/AbstractPart;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPMessage_setMainPart
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPMessage
+ * Method:    mainPart
+ * Signature: ()Lcom/libmailcore/AbstractPart;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPMessage_mainPart
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPMessage
+ * Method:    setGmailLabels
+ * Signature: (Ljava/util/List;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPMessage_setGmailLabels
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPMessage
+ * Method:    gmailLabels
+ * Signature: ()Ljava/util/List;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPMessage_gmailLabels
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPMessage
+ * Method:    setGmailMessageID
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPMessage_setGmailMessageID
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_libmailcore_IMAPMessage
+ * Method:    gmailMessageID
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_libmailcore_IMAPMessage_gmailMessageID
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPMessage
+ * Method:    setGmailThreadID
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPMessage_setGmailThreadID
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_libmailcore_IMAPMessage
+ * Method:    gmailThreadID
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_libmailcore_IMAPMessage_gmailThreadID
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPMessage
+ * Method:    partForPartID
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/AbstractPart;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPMessage_partForPartID
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPMessage
+ * Method:    partForContentID
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/AbstractPart;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPMessage_partForContentID
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPMessage
+ * Method:    partForUniqueID
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/AbstractPart;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPMessage_partForUniqueID
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPMessage
+ * Method:    htmlRendering
+ * Signature: (Ljava/lang/String;Lcom/libmailcore/HTMLRendererIMAPCallback;Lcom/libmailcore/HTMLRendererTemplateCallback;)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPMessage_htmlRendering
+  (JNIEnv *, jobject, jstring, jobject, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPMessagePart.cpp b/src/java/native/com_libmailcore_IMAPMessagePart.cpp
new file mode 100644
index 00000000..5ca19ab8
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPMessagePart.cpp
@@ -0,0 +1,15 @@
+#include "com_libmailcore_IMAPMessagePart.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCIMAPMessagePart.h"
+
+using namespace mailcore;
+
+#define nativeType IMAPMessagePart
+#define javaType nativeType
+
+MC_JAVA_SYNTHESIZE_STRING(setPartID, partID)
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IMAPMessagePart.h b/src/java/native/com_libmailcore_IMAPMessagePart.h
new file mode 100644
index 00000000..31675977
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPMessagePart.h
@@ -0,0 +1,29 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPMessagePart */
+
+#ifndef _Included_com_libmailcore_IMAPMessagePart
+#define _Included_com_libmailcore_IMAPMessagePart
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IMAPMessagePart
+ * Method:    setPartID
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPMessagePart_setPartID
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPMessagePart
+ * Method:    partID
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPMessagePart_partID
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPMessageRenderingOperation.cpp b/src/java/native/com_libmailcore_IMAPMessageRenderingOperation.cpp
new file mode 100644
index 00000000..106996a1
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPMessageRenderingOperation.cpp
@@ -0,0 +1,19 @@
+#include "com_libmailcore_IMAPMessageRenderingOperation.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCIMAPMessageRenderingOperation.h"
+
+using namespace mailcore;
+
+#define nativeType IMAPMessageRenderingOperation
+#define javaType nativeType
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPMessageRenderingOperation_result
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET_STRING(result);
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IMAPMessageRenderingOperation.h b/src/java/native/com_libmailcore_IMAPMessageRenderingOperation.h
new file mode 100644
index 00000000..e2afd390
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPMessageRenderingOperation.h
@@ -0,0 +1,21 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPMessageRenderingOperation */
+
+#ifndef _Included_com_libmailcore_IMAPMessageRenderingOperation
+#define _Included_com_libmailcore_IMAPMessageRenderingOperation
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IMAPMessageRenderingOperation
+ * Method:    result
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPMessageRenderingOperation_result
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPMultipart.cpp b/src/java/native/com_libmailcore_IMAPMultipart.cpp
new file mode 100644
index 00000000..dbf5eceb
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPMultipart.cpp
@@ -0,0 +1,15 @@
+#include "com_libmailcore_IMAPMultipart.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCIMAPMultipart.h"
+
+using namespace mailcore;
+
+#define nativeType IMAPMultipart
+#define javaType nativeType
+
+MC_JAVA_SYNTHESIZE_STRING(setPartID, partID)
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IMAPMultipart.h b/src/java/native/com_libmailcore_IMAPMultipart.h
new file mode 100644
index 00000000..3aec59b6
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPMultipart.h
@@ -0,0 +1,37 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPMultipart */
+
+#ifndef _Included_com_libmailcore_IMAPMultipart
+#define _Included_com_libmailcore_IMAPMultipart
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IMAPMultipart
+ * Method:    setPartID
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPMultipart_setPartID
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPMultipart
+ * Method:    partID
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPMultipart_partID
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPMultipart
+ * Method:    setupNative
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPMultipart_setupNative
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPNamespace.cpp b/src/java/native/com_libmailcore_IMAPNamespace.cpp
new file mode 100644
index 00000000..3569ea55
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPNamespace.cpp
@@ -0,0 +1,62 @@
+#include "com_libmailcore_IMAPNamespace.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCIMAPNamespace.h"
+
+using namespace mailcore;
+
+#define nativeType IMAPNamespace
+#define javaType nativeType
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPNamespace_mainPrefix
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET_STRING(mainPrefix);
+}
+
+JNIEXPORT jchar JNICALL Java_com_libmailcore_IMAPNamespace_mainDelimiter
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET_SCALAR(jchar, mainDelimiter);
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPNamespace_prefixes
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET(prefixes);
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPNamespace_pathForComponents
+  (JNIEnv * env, jobject obj, jobject components)
+{
+    return (jstring) MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->pathForComponents(MC_FROM_JAVA(Array, components)));
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPNamespace_pathForComponentsAndPrefix
+  (JNIEnv * env, jobject obj, jobject components, jstring prefix)
+{
+    return (jstring) MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->pathForComponentsAndPrefix(MC_FROM_JAVA(Array, components),
+        MC_FROM_JAVA(String, prefix)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPNamespace_componentsFromPath
+  (JNIEnv * env, jobject obj, jstring path)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->componentsFromPath(MC_FROM_JAVA(String, path)));
+}
+
+JNIEXPORT jboolean JNICALL Java_com_libmailcore_IMAPNamespace_containsFolderPath
+  (JNIEnv * env, jobject obj, jstring path)
+{
+    return (jboolean) MC_JAVA_NATIVE_INSTANCE->containsFolderPath(MC_FROM_JAVA(String, path));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPNamespace_namespaceWithPrefix
+  (JNIEnv * env, jclass cls, jstring prefix, jchar delimiter)
+{
+    return MC_TO_JAVA(IMAPNamespace::namespaceWithPrefix(MC_FROM_JAVA(String, prefix), (char) delimiter));
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IMAPNamespace.h b/src/java/native/com_libmailcore_IMAPNamespace.h
new file mode 100644
index 00000000..5ffa4a79
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPNamespace.h
@@ -0,0 +1,77 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPNamespace */
+
+#ifndef _Included_com_libmailcore_IMAPNamespace
+#define _Included_com_libmailcore_IMAPNamespace
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IMAPNamespace
+ * Method:    mainPrefix
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPNamespace_mainPrefix
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPNamespace
+ * Method:    mainDelimiter
+ * Signature: ()C
+ */
+JNIEXPORT jchar JNICALL Java_com_libmailcore_IMAPNamespace_mainDelimiter
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPNamespace
+ * Method:    prefixes
+ * Signature: ()Ljava/util/List;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPNamespace_prefixes
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPNamespace
+ * Method:    pathForComponents
+ * Signature: (Ljava/util/List;)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPNamespace_pathForComponents
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPNamespace
+ * Method:    pathForComponentsAndPrefix
+ * Signature: (Ljava/util/List;Ljava/lang/String;)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPNamespace_pathForComponentsAndPrefix
+  (JNIEnv *, jobject, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPNamespace
+ * Method:    componentsFromPath
+ * Signature: (Ljava/lang/String;)Ljava/util/List;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPNamespace_componentsFromPath
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPNamespace
+ * Method:    containsFolderPath
+ * Signature: (Ljava/lang/String;)Z
+ */
+JNIEXPORT jboolean JNICALL Java_com_libmailcore_IMAPNamespace_containsFolderPath
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPNamespace
+ * Method:    namespaceWithPrefix
+ * Signature: (Ljava/lang/String;C)Lcom/libmailcore/IMAPNamespace;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPNamespace_namespaceWithPrefix
+  (JNIEnv *, jclass, jstring, jchar);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPNamespaceItem.cpp b/src/java/native/com_libmailcore_IMAPNamespaceItem.cpp
new file mode 100644
index 00000000..ace55219
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPNamespaceItem.cpp
@@ -0,0 +1,34 @@
+#include "com_libmailcore_IMAPNamespaceItem.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCIMAPNamespaceItem.h"
+
+using namespace mailcore;
+
+#define nativeType IMAPNamespaceItem
+#define javaType nativeType
+
+MC_JAVA_SYNTHESIZE_STRING(setPrefix, prefix)
+MC_JAVA_SYNTHESIZE_SCALAR(jchar, char, setDelimiter, delimiter)
+    
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPNamespaceItem_pathForComponents
+  (JNIEnv * env, jobject obj, jobject components)
+{
+    return (jstring) MC_JAVA_NATIVE_INSTANCE->pathForComponents(MC_FROM_JAVA(Array, components));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPNamespaceItem_componentsForPath
+  (JNIEnv * env, jobject obj, jstring path)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->componentsForPath(MC_FROM_JAVA(String, path)));
+}
+
+JNIEXPORT jboolean JNICALL Java_com_libmailcore_IMAPNamespaceItem_containsFolder
+  (JNIEnv * env, jobject obj, jstring path)
+{
+    return (jboolean) MC_JAVA_NATIVE_INSTANCE->containsFolder(MC_FROM_JAVA(String, path));
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IMAPNamespaceItem.h b/src/java/native/com_libmailcore_IMAPNamespaceItem.h
new file mode 100644
index 00000000..13f6ac0d
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPNamespaceItem.h
@@ -0,0 +1,69 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPNamespaceItem */
+
+#ifndef _Included_com_libmailcore_IMAPNamespaceItem
+#define _Included_com_libmailcore_IMAPNamespaceItem
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IMAPNamespaceItem
+ * Method:    setPrefix
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPNamespaceItem_setPrefix
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPNamespaceItem
+ * Method:    prefix
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPNamespaceItem_prefix
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPNamespaceItem
+ * Method:    setDelimiter
+ * Signature: (C)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPNamespaceItem_setDelimiter
+  (JNIEnv *, jobject, jchar);
+
+/*
+ * Class:     com_libmailcore_IMAPNamespaceItem
+ * Method:    delimiter
+ * Signature: ()C
+ */
+JNIEXPORT jchar JNICALL Java_com_libmailcore_IMAPNamespaceItem_delimiter
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPNamespaceItem
+ * Method:    pathForComponents
+ * Signature: (Ljava/util/List;)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPNamespaceItem_pathForComponents
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPNamespaceItem
+ * Method:    componentsForPath
+ * Signature: (Ljava/lang/String;)Ljava/util/List;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPNamespaceItem_componentsForPath
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPNamespaceItem
+ * Method:    containsFolder
+ * Signature: (Ljava/lang/String;)Z
+ */
+JNIEXPORT jboolean JNICALL Java_com_libmailcore_IMAPNamespaceItem_containsFolder
+  (JNIEnv *, jobject, jstring);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPOperation.cpp b/src/java/native/com_libmailcore_IMAPOperation.cpp
new file mode 100644
index 00000000..74e4f15c
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPOperation.cpp
@@ -0,0 +1,25 @@
+#include "com_libmailcore_IMAPOperation.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCIMAPOperation.h"
+
+using namespace mailcore;
+
+#define nativeType IMAPOperation
+#define javaType nativeType
+
+JNIEXPORT jint JNICALL Java_com_libmailcore_IMAPOperation_errorCode
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET_SCALAR(jint, error);
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPOperation_errorMessage
+  (JNIEnv * env, jobject obj)
+{
+    return (jstring) MC_TO_JAVA(MCSTR("Operation failed"));
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IMAPOperation.h b/src/java/native/com_libmailcore_IMAPOperation.h
new file mode 100644
index 00000000..b93ecceb
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPOperation.h
@@ -0,0 +1,21 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPOperation */
+
+#ifndef _Included_com_libmailcore_IMAPOperation
+#define _Included_com_libmailcore_IMAPOperation
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IMAPOperation
+ * Method:    errorCode
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_libmailcore_IMAPOperation_errorCode
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPOperationItemProgressListener.h b/src/java/native/com_libmailcore_IMAPOperationItemProgressListener.h
new file mode 100644
index 00000000..e1b80e9d
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPOperationItemProgressListener.h
@@ -0,0 +1,13 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPOperationItemProgressListener */
+
+#ifndef _Included_com_libmailcore_IMAPOperationItemProgressListener
+#define _Included_com_libmailcore_IMAPOperationItemProgressListener
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPOperationProgressListener.h b/src/java/native/com_libmailcore_IMAPOperationProgressListener.h
new file mode 100644
index 00000000..e94fceb7
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPOperationProgressListener.h
@@ -0,0 +1,13 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPOperationProgressListener */
+
+#ifndef _Included_com_libmailcore_IMAPOperationProgressListener
+#define _Included_com_libmailcore_IMAPOperationProgressListener
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPPart.cpp b/src/java/native/com_libmailcore_IMAPPart.cpp
new file mode 100644
index 00000000..6c5ae806
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPPart.cpp
@@ -0,0 +1,23 @@
+#include "com_libmailcore_IMAPPart.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCIMAPPart.h"
+
+using namespace mailcore;
+
+#define nativeType IMAPPart
+#define javaType nativeType
+
+MC_JAVA_SYNTHESIZE_STRING(setPartID, partID)
+MC_JAVA_SYNTHESIZE_SCALAR(jlong, unsigned int, setSize, size)
+MC_JAVA_SYNTHESIZE_SCALAR(jint, Encoding, setEncoding, encoding)
+
+JNIEXPORT jlong JNICALL Java_com_libmailcore_IMAPPart_decodedSize
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET_SCALAR(jlong, decodedSize);
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IMAPPart.h b/src/java/native/com_libmailcore_IMAPPart.h
new file mode 100644
index 00000000..283fcec9
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPPart.h
@@ -0,0 +1,69 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPPart */
+
+#ifndef _Included_com_libmailcore_IMAPPart
+#define _Included_com_libmailcore_IMAPPart
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IMAPPart
+ * Method:    setPartID
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPPart_setPartID
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPPart
+ * Method:    partID
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPPart_partID
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPPart
+ * Method:    setSize
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPPart_setSize
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_libmailcore_IMAPPart
+ * Method:    size
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_libmailcore_IMAPPart_size
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPPart
+ * Method:    decodedSize
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_libmailcore_IMAPPart_decodedSize
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPPart
+ * Method:    setEncoding
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPPart_setEncoding
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_libmailcore_IMAPPart
+ * Method:    encoding
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_libmailcore_IMAPPart_encoding
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPQuotaOperation.cpp b/src/java/native/com_libmailcore_IMAPQuotaOperation.cpp
new file mode 100644
index 00000000..5ac954f0
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPQuotaOperation.cpp
@@ -0,0 +1,25 @@
+#include "com_libmailcore_IMAPQuotaOperation.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCIMAPQuotaOperation.h"
+
+using namespace mailcore;
+
+#define nativeType IMAPQuotaOperation
+#define javaType nativeType
+
+JNIEXPORT jint JNICALL Java_com_libmailcore_IMAPQuotaOperation_usage
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET_SCALAR(jint, usage);
+}
+
+JNIEXPORT jint JNICALL Java_com_libmailcore_IMAPQuotaOperation_limit
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET_SCALAR(jint, limit);
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IMAPQuotaOperation.h b/src/java/native/com_libmailcore_IMAPQuotaOperation.h
new file mode 100644
index 00000000..3ff29f22
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPQuotaOperation.h
@@ -0,0 +1,29 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPQuotaOperation */
+
+#ifndef _Included_com_libmailcore_IMAPQuotaOperation
+#define _Included_com_libmailcore_IMAPQuotaOperation
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IMAPQuotaOperation
+ * Method:    usage
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_libmailcore_IMAPQuotaOperation_usage
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPQuotaOperation
+ * Method:    limit
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_libmailcore_IMAPQuotaOperation_limit
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPSearchExpression.cpp b/src/java/native/com_libmailcore_IMAPSearchExpression.cpp
new file mode 100644
index 00000000..75f2c3ec
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPSearchExpression.cpp
@@ -0,0 +1,223 @@
+#include "com_libmailcore_IMAPSearchExpression.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCIMAPSearchExpression.h"
+
+using namespace mailcore;
+
+#define nativeType IMAPSearchExpression
+#define javaType nativeType
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchAll
+  (JNIEnv * env, jclass cls)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchAll());
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchFrom
+  (JNIEnv * env, jclass cls, jstring)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchAll());
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchTo
+  (JNIEnv * env, jclass cls, jstring value)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchTo(MC_FROM_JAVA(String, value)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchCc
+  (JNIEnv * env, jclass cls, jstring value)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchCc(MC_FROM_JAVA(String, value)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchBcc
+  (JNIEnv * env, jclass cls, jstring value)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchBcc(MC_FROM_JAVA(String, value)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchRecipient
+  (JNIEnv * env, jclass cls, jstring value)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchRecipient(MC_FROM_JAVA(String, value)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchSubject
+  (JNIEnv * env, jclass cls, jstring value)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchSubject(MC_FROM_JAVA(String, value)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchContent
+  (JNIEnv * env, jclass cls, jstring value)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchContent(MC_FROM_JAVA(String, value)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchBody
+  (JNIEnv * env, jclass cls, jstring value)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchBody(MC_FROM_JAVA(String, value)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchHeader
+  (JNIEnv * env, jclass cls, jstring header, jstring value)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchHeader(MC_FROM_JAVA(String, header), MC_FROM_JAVA(String, value)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchUIDs
+  (JNIEnv * env, jclass cls, jobject uids)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchUIDs(MC_FROM_JAVA(IndexSet, uids)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchRead
+  (JNIEnv * env, jclass cls)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchRead());
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchUnread
+  (JNIEnv * env, jclass cls)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchUnread());
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchFlagged
+  (JNIEnv * env, jclass cls)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchFlagged());
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchUnflagged
+  (JNIEnv * env, jclass cls)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchUnflagged());
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchAnswered
+  (JNIEnv * env, jclass cls)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchAnswered());
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchUnanswered
+  (JNIEnv * env, jclass cls)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchUnanswered());
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchDraft
+  (JNIEnv * env, jclass cls)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchDraft());
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchUndraft
+  (JNIEnv * env, jclass cls)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchUndraft());
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchDeleted
+  (JNIEnv * env, jclass cls)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchDeleted());
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchSpam
+  (JNIEnv * env, jclass cls)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchSpam());
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchBeforeDate
+  (JNIEnv * env, jclass cls, jobject date)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchBeforeDate(javaDateToTime(env, date)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchOnDate
+  (JNIEnv * env, jclass cls, jobject date)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchOnDate(javaDateToTime(env, date)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchSinceDate
+  (JNIEnv * env, jclass cls, jobject date)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchSinceDate(javaDateToTime(env, date)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchBeforeReceivedDate
+  (JNIEnv * env, jclass cls, jobject date)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchBeforeDate(javaDateToTime(env, date)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchOnReceivedDate
+  (JNIEnv * env, jclass cls, jobject date)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchOnReceivedDate(javaDateToTime(env, date)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchSinceReceivedDate
+  (JNIEnv * env, jclass cls, jobject date)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchSinceReceivedDate(javaDateToTime(env, date)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchSizeLarger
+  (JNIEnv * env, jclass cls, jlong size)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchSizeLarger((uint32_t) size));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchSizeSmaller
+  (JNIEnv * env, jclass cls, jlong size)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchSizeSmaller((uint32_t) size));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchGmailThreadID
+  (JNIEnv * env, jclass cls, jlong threadID)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchGmailThreadID((uint64_t) threadID));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchGmailMessageID
+  (JNIEnv * env, jclass cls, jlong messageID)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchGmailThreadID((uint64_t) messageID));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchGmailRaw
+  (JNIEnv * env, jclass cls, jstring searchString)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchGmailRaw(MC_FROM_JAVA(String, searchString)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchAnd
+  (JNIEnv * env, jclass cls, jobject expr1, jobject expr2)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchAnd(MC_FROM_JAVA(IMAPSearchExpression, expr1), MC_FROM_JAVA(IMAPSearchExpression, expr2)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchOr
+  (JNIEnv * env, jclass cls, jobject expr1, jobject expr2)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchOr(MC_FROM_JAVA(IMAPSearchExpression, expr1), MC_FROM_JAVA(IMAPSearchExpression, expr2)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchNot
+  (JNIEnv * env, jclass cls, jobject expr)
+{
+    return MC_TO_JAVA(IMAPSearchExpression::searchNot(MC_FROM_JAVA(IMAPSearchExpression, expr)));
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IMAPSearchExpression.h b/src/java/native/com_libmailcore_IMAPSearchExpression.h
new file mode 100644
index 00000000..29853074
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPSearchExpression.h
@@ -0,0 +1,301 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPSearchExpression */
+
+#ifndef _Included_com_libmailcore_IMAPSearchExpression
+#define _Included_com_libmailcore_IMAPSearchExpression
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchAll
+ * Signature: ()Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchAll
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchFrom
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchFrom
+  (JNIEnv *, jclass, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchTo
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchTo
+  (JNIEnv *, jclass, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchCc
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchCc
+  (JNIEnv *, jclass, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchBcc
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchBcc
+  (JNIEnv *, jclass, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchRecipient
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchRecipient
+  (JNIEnv *, jclass, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchSubject
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchSubject
+  (JNIEnv *, jclass, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchContent
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchContent
+  (JNIEnv *, jclass, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchBody
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchBody
+  (JNIEnv *, jclass, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchHeader
+ * Signature: (Ljava/lang/String;Ljava/lang/String;)Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchHeader
+  (JNIEnv *, jclass, jstring, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchUIDs
+ * Signature: (Lcom/libmailcore/IndexSet;)Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchUIDs
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchRead
+ * Signature: ()Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchRead
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchUnread
+ * Signature: ()Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchUnread
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchFlagged
+ * Signature: ()Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchFlagged
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchUnflagged
+ * Signature: ()Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchUnflagged
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchAnswered
+ * Signature: ()Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchAnswered
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchUnanswered
+ * Signature: ()Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchUnanswered
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchDraft
+ * Signature: ()Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchDraft
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchUndraft
+ * Signature: ()Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchUndraft
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchDeleted
+ * Signature: ()Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchDeleted
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchSpam
+ * Signature: ()Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchSpam
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchBeforeDate
+ * Signature: (Ljava/util/Date;)Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchBeforeDate
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchOnDate
+ * Signature: (Ljava/util/Date;)Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchOnDate
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchSinceDate
+ * Signature: (Ljava/util/Date;)Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchSinceDate
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchBeforeReceivedDate
+ * Signature: (Ljava/util/Date;)Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchBeforeReceivedDate
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchOnReceivedDate
+ * Signature: (Ljava/util/Date;)Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchOnReceivedDate
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchSinceReceivedDate
+ * Signature: (Ljava/util/Date;)Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchSinceReceivedDate
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchSizeLarger
+ * Signature: (J)Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchSizeLarger
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchSizeSmaller
+ * Signature: (J)Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchSizeSmaller
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchGmailThreadID
+ * Signature: (J)Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchGmailThreadID
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchGmailMessageID
+ * Signature: (J)Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchGmailMessageID
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchGmailRaw
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchGmailRaw
+  (JNIEnv *, jclass, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchAnd
+ * Signature: (Lcom/libmailcore/IMAPSearchExpression;Lcom/libmailcore/IMAPSearchExpression;)Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchAnd
+  (JNIEnv *, jclass, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchOr
+ * Signature: (Lcom/libmailcore/IMAPSearchExpression;Lcom/libmailcore/IMAPSearchExpression;)Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchOr
+  (JNIEnv *, jclass, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    searchNot
+ * Signature: (Lcom/libmailcore/IMAPSearchExpression;)Lcom/libmailcore/IMAPSearchExpression;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchExpression_searchNot
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSearchExpression
+ * Method:    setupNative
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPSearchExpression_setupNative
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPSearchKind.h b/src/java/native/com_libmailcore_IMAPSearchKind.h
new file mode 100644
index 00000000..c6a257ba
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPSearchKind.h
@@ -0,0 +1,85 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPSearchKind */
+
+#ifndef _Included_com_libmailcore_IMAPSearchKind
+#define _Included_com_libmailcore_IMAPSearchKind
+#ifdef __cplusplus
+extern "C" {
+#endif
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindAll
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindAll 0L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindNone
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindNone 1L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindFrom
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindFrom 2L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindTo
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindTo 3L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindCc
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindCc 4L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindBcc
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindBcc 5L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindRecipient
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindRecipient 6L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindSubject
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindSubject 7L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindContent
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindContent 8L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindBody
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindBody 9L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindUids
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindUids 10L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindHeader
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindHeader 11L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindRead
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindRead 12L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindUnread
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindUnread 13L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindFlagged
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindFlagged 14L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindUnflagged
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindUnflagged 15L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindAnswered
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindAnswered 16L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindUnanswered
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindUnanswered 17L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindDraft
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindDraft 18L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindUndraft
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindUndraft 19L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindDeleted
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindDeleted 20L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindSpam
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindSpam 21L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindBeforeDate
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindBeforeDate 22L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindOnDate
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindOnDate 23L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindSinceDate
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindSinceDate 24L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindBeforeReceivedDate
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindBeforeReceivedDate 25L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindOnReceivedDate
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindOnReceivedDate 26L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindSinceReceivedDate
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindSinceReceivedDate 27L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindSizeLarger
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindSizeLarger 28L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindSizeSmaller
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindSizeSmaller 29L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindGmailThreadID
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindGmailThreadID 30L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindGmailMessageID
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindGmailMessageID 31L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindGmailRaw
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindGmailRaw 32L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindOr
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindOr 33L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindAnd
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindAnd 34L
+#undef com_libmailcore_IMAPSearchKind_IMAPSearchKindNot
+#define com_libmailcore_IMAPSearchKind_IMAPSearchKindNot 35L
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPSearchOperation.cpp b/src/java/native/com_libmailcore_IMAPSearchOperation.cpp
new file mode 100644
index 00000000..f9b3f524
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPSearchOperation.cpp
@@ -0,0 +1,19 @@
+#include "com_libmailcore_IMAPSearchOperation.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCIMAPSearchOperation.h"
+
+using namespace mailcore;
+
+#define nativeType IMAPSearchOperation
+#define javaType nativeType
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchOperation_uids
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET(uids);
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IMAPSearchOperation.h b/src/java/native/com_libmailcore_IMAPSearchOperation.h
new file mode 100644
index 00000000..2204afe8
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPSearchOperation.h
@@ -0,0 +1,21 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPSearchOperation */
+
+#ifndef _Included_com_libmailcore_IMAPSearchOperation
+#define _Included_com_libmailcore_IMAPSearchOperation
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IMAPSearchOperation
+ * Method:    uids
+ * Signature: ()Lcom/libmailcore/IndexSet;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSearchOperation_uids
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPSession.cpp b/src/java/native/com_libmailcore_IMAPSession.cpp
new file mode 100644
index 00000000..ee76a76a
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPSession.cpp
@@ -0,0 +1,356 @@
+#include "com_libmailcore_IMAPSession.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+#include "MCIMAPAsyncSession.h"
+#include "JavaOperationQueueCallback.h"
+#include "JavaConnectionLogger.h"
+
+using namespace mailcore;
+
+#define nativeType IMAPAsyncSession
+#define javaType IMAPSession
+
+MC_JAVA_SYNTHESIZE_STRING(setHostname, hostname)
+MC_JAVA_SYNTHESIZE_SCALAR(jint, unsigned int, setPort, port)
+MC_JAVA_SYNTHESIZE_STRING(setUsername, username)
+MC_JAVA_SYNTHESIZE_STRING(setPassword, password)
+MC_JAVA_SYNTHESIZE_STRING(setOAuth2Token, OAuth2Token)
+MC_JAVA_SYNTHESIZE_SCALAR(jint, AuthType, setAuthType, authType)
+MC_JAVA_SYNTHESIZE_SCALAR(jint, ConnectionType, setConnectionType, connectionType)
+MC_JAVA_SYNTHESIZE_SCALAR(jlong, time_t, setTimeout, timeout)
+MC_JAVA_SYNTHESIZE_SCALAR(jboolean, bool, setCheckCertificateEnabled, isCheckCertificateEnabled)
+MC_JAVA_SYNTHESIZE(IMAPNamespace, setDefaultNamespace, defaultNamespace)
+MC_JAVA_SYNTHESIZE_SCALAR(jboolean, bool, setAllowsFolderConcurrentAccessEnabled, allowsFolderConcurrentAccessEnabled)
+MC_JAVA_SYNTHESIZE_SCALAR(jint, unsigned int, setMaximumConnections, maximumConnections)
+
+JNIEXPORT jboolean JNICALL Java_com_libmailcore_IMAPSession_isOperationQueueRunning
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET_SCALAR(jboolean, isOperationQueueRunning);
+}
+
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPSession_cancelAllOperations
+  (JNIEnv * env, jobject obj)
+{
+    MC_JAVA_NATIVE_INSTANCE->cancelAllOperations();
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_serverIdentity
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET(serverIdentity);
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_clientIdentity
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET(clientIdentity);
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPSession_gmailUserDisplayName
+  (JNIEnv * env, jobject obj)
+{
+    return (jstring) MC_JAVA_BRIDGE_GET(gmailUserDisplayName);
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_folderInfoOperation
+  (JNIEnv * env, jobject obj, jstring path)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->folderInfoOperation(MC_FROM_JAVA(String, path)));
+}
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    folderStatusOperation
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/IMAPFolderStatusOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_folderStatusOperation
+  (JNIEnv * env, jobject obj, jstring path)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->folderInfoOperation(MC_FROM_JAVA(String, path)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_fetchSubscribedFoldersOperation
+  (JNIEnv * env, jobject obj)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->fetchSubscribedFoldersOperation());
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_fetchAllFoldersOperation
+  (JNIEnv * env, jobject obj)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->fetchAllFoldersOperation());
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_renameFolderOperation
+  (JNIEnv * env, jobject obj, jstring currentName, jstring otherName)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->renameFolderOperation(MC_FROM_JAVA(String, currentName), MC_FROM_JAVA(String, otherName)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_deleteFolderOperation
+  (JNIEnv * env, jobject obj, jstring path)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->deleteFolderOperation(MC_FROM_JAVA(String, path)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_createFolderOperation
+  (JNIEnv * env, jobject obj, jstring path)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->createFolderOperation(MC_FROM_JAVA(String, path)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_subscribeFolderOperation
+  (JNIEnv * env, jobject obj, jstring path)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->subscribeFolderOperation(MC_FROM_JAVA(String, path)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_unsubscribeFolderOperation
+  (JNIEnv * env, jobject obj, jstring path)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->unsubscribeFolderOperation(MC_FROM_JAVA(String, path)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_appendMessageOperation
+  (JNIEnv * env, jobject obj, jstring path, jbyteArray data, jint flags, jobject customFlags)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->appendMessageOperation(MC_FROM_JAVA(String, path),
+        MC_FROM_JAVA(Data, data), (MessageFlag) flags, MC_FROM_JAVA(Array, customFlags)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_copyMessagesOperation
+  (JNIEnv * env, jobject obj, jstring sourcePath, jobject uids, jstring destPath)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->copyMessagesOperation(MC_FROM_JAVA(String, sourcePath),
+        MC_FROM_JAVA(IndexSet, uids), MC_FROM_JAVA(String, destPath)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_expungeOperation
+  (JNIEnv * env, jobject obj, jstring path)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->expungeOperation(MC_FROM_JAVA(String, path)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_fetchMessagesByUIDOperation
+  (JNIEnv * env, jobject obj, jstring path, jint kind, jobject uids)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->fetchMessagesByUIDOperation(MC_FROM_JAVA(String, path), (IMAPMessagesRequestKind) kind, MC_FROM_JAVA(IndexSet, uids)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_fetchMessagesByNumberOperation
+  (JNIEnv * env, jobject obj, jstring path, jint kind, jobject numbers)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->fetchMessagesByNumberOperation(MC_FROM_JAVA(String, path), (IMAPMessagesRequestKind) kind, MC_FROM_JAVA(IndexSet, numbers)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_syncMessagesByUIDOperation
+  (JNIEnv * env, jobject obj, jstring path, jint kind, jobject uids, jlong modSeq)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->syncMessagesByUIDOperation(MC_FROM_JAVA(String, path), (IMAPMessagesRequestKind) kind, MC_FROM_JAVA(IndexSet, uids), (uint64_t) modSeq));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_fetchMessageByUIDOperation
+  (JNIEnv * env, jobject obj, jstring path, jlong uid, jboolean urgent)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->fetchMessageByUIDOperation(MC_FROM_JAVA(String, path), (uint32_t) uid, (bool) urgent));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_fetchMessageAttachmentByUIDOperation
+  (JNIEnv * env, jobject obj, jstring path, jlong uid, jstring partID, jint encoding, jboolean urgent)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->fetchMessageAttachmentByUIDOperation(MC_FROM_JAVA(String, path),
+        (uint32_t) uid, MC_FROM_JAVA(String, partID), (Encoding) encoding, (bool) urgent));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_fetchMessageByNumberOperation
+  (JNIEnv * env, jobject obj, jstring path, jlong number, jboolean urgent)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->fetchMessageByNumberOperation(MC_FROM_JAVA(String, path),
+        (uint32_t) number, (bool) urgent));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_fetchMessageAttachmentByNumberOperation
+  (JNIEnv * env, jobject obj, jstring path, jlong number, jstring partID, jint encoding, jboolean urgent)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->fetchMessageAttachmentByNumberOperation(MC_FROM_JAVA(String, path),
+        (uint32_t) number, MC_FROM_JAVA(String, partID), (Encoding) encoding, (bool) urgent));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_fetchParsedMessageByUIDOperation
+  (JNIEnv * env, jobject obj, jstring path, jlong uid, jboolean urgent)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->fetchParsedMessageByUIDOperation(MC_FROM_JAVA(String, path),
+        (uint32_t) uid, (bool) urgent));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_fetchParsedMessageByNumberOperation
+  (JNIEnv * env, jobject obj, jstring path, jlong number, jboolean urgent)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->fetchParsedMessageByNumberOperation(MC_FROM_JAVA(String, path),
+        (uint32_t) number, (bool) urgent));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_storeFlagsByUIDOperation
+  (JNIEnv * env, jobject obj, jstring path, jobject uids, jint kind, jint flags, jobject customFlags)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->storeFlagsByUIDOperation(MC_FROM_JAVA(String, path),
+        MC_FROM_JAVA(IndexSet, uids), (IMAPStoreFlagsRequestKind) kind, (MessageFlag) flags, MC_FROM_JAVA(Array, customFlags)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_storeFlagsByNumberOperation
+  (JNIEnv * env, jobject obj, jstring path, jobject uids, jint kind, jint flags, jobject customFlags)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->storeFlagsByUIDOperation(MC_FROM_JAVA(String, path),
+        MC_FROM_JAVA(IndexSet, uids), (IMAPStoreFlagsRequestKind) kind, (MessageFlag) flags, MC_FROM_JAVA(Array, customFlags)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_storeLabelsByUIDOperation
+  (JNIEnv * env, jobject obj, jstring path, jobject uids, jint kind, jobject labels)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->storeLabelsByUIDOperation(MC_FROM_JAVA(String, path),
+        MC_FROM_JAVA(IndexSet, uids), (IMAPStoreFlagsRequestKind) kind, MC_FROM_JAVA(Array, labels)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_storeLabelsByNumberOperation
+  (JNIEnv * env, jobject obj, jstring path, jobject numbers, jint kind, jobject labels)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->storeLabelsByNumberOperation(MC_FROM_JAVA(String, path),
+        MC_FROM_JAVA(IndexSet, numbers), (IMAPStoreFlagsRequestKind) kind, MC_FROM_JAVA(Array, labels)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_searchOperation__Ljava_lang_String_2ILjava_lang_String_2
+  (JNIEnv * env, jobject obj, jstring path, jint kind, jstring searchString)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->searchOperation(MC_FROM_JAVA(String, path),
+        (IMAPSearchKind) kind, MC_FROM_JAVA(String, searchString)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_searchOperation__Ljava_lang_String_2Lcom_libmailcore_IMAPSearchExpression_2
+  (JNIEnv * env, jobject obj, jstring path, jobject expression)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->searchOperation(MC_FROM_JAVA(String, path),
+        MC_FROM_JAVA(IMAPSearchExpression, expression)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_idleOperation
+  (JNIEnv * env, jobject obj, jstring path, jlong lastKnownUID)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->idleOperation(MC_FROM_JAVA(String, path), (uint32_t) lastKnownUID));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_fetchNamespaceOperation
+  (JNIEnv * env, jobject obj)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->fetchNamespaceOperation());
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_identityOperation
+  (JNIEnv * env, jobject obj, jobject identity)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->identityOperation(MC_FROM_JAVA(IMAPIdentity, identity)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_connectOperation
+  (JNIEnv * env, jobject obj)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->connectOperation());
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_checkAccountOperation
+  (JNIEnv * env, jobject obj)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->checkAccountOperation());
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_disconnectOperation
+  (JNIEnv * env, jobject obj)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->disconnectOperation());
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_capabilityOperation
+  (JNIEnv * env, jobject obj)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->capabilityOperation());
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_quotaOperation
+  (JNIEnv * env, jobject obj)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->quotaOperation());
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_noopOperation
+  (JNIEnv * env, jobject obj)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->noopOperation());
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_htmlRenderingOperation
+  (JNIEnv * env, jobject obj, jobject msg, jstring path)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->htmlRenderingOperation(MC_FROM_JAVA(IMAPMessage, msg), MC_FROM_JAVA(String, path)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_htmlBodyRenderingOperation
+  (JNIEnv * env, jobject obj, jobject msg, jstring path)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->htmlBodyRenderingOperation(MC_FROM_JAVA(IMAPMessage, msg), MC_FROM_JAVA(String, path)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_plainTextRenderingOperation
+  (JNIEnv * env, jobject obj, jobject msg, jstring path)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->plainTextRenderingOperation(MC_FROM_JAVA(IMAPMessage, msg), MC_FROM_JAVA(String, path)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_plainTextBodyRenderingOperation
+  (JNIEnv * env, jobject obj, jobject msg, jstring path, jboolean stripWhitespace)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->plainTextBodyRenderingOperation(MC_FROM_JAVA(IMAPMessage, msg), MC_FROM_JAVA(String, path), (bool) stripWhitespace));
+}
+
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPSession_finalizeNative
+  (JNIEnv * env, jobject obj)
+{
+    JavaOperationQueueCallback * callback = (JavaOperationQueueCallback *) MC_JAVA_NATIVE_INSTANCE->operationQueueCallback();
+    MC_SAFE_RELEASE(callback);
+    MC_JAVA_NATIVE_INSTANCE->setOperationQueueCallback(NULL);
+
+    JavaConnectionLogger * logger = (JavaConnectionLogger *) MC_JAVA_NATIVE_INSTANCE->connectionLogger();
+    MC_SAFE_RELEASE(logger);
+    MC_JAVA_NATIVE_INSTANCE->setConnectionLogger(NULL);
+}
+
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPSession_setupNativeOperationQueueListener
+  (JNIEnv * env, jobject obj)
+{
+    JavaOperationQueueCallback * callback = (JavaOperationQueueCallback *) MC_JAVA_NATIVE_INSTANCE->operationQueueCallback();
+    MC_SAFE_RELEASE(callback);
+    MC_JAVA_NATIVE_INSTANCE->setOperationQueueCallback(NULL);
+
+    jobject javaListener = getObjectField(env, obj, "operationQueueListener");
+    if (javaListener != NULL) {
+        callback = new JavaOperationQueueCallback(env, javaListener);
+        MC_JAVA_NATIVE_INSTANCE->setOperationQueueCallback(callback);
+    }
+}
+
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPSession_setupNativeConnectionLogger
+  (JNIEnv * env, jobject obj)
+{
+    JavaConnectionLogger * logger = (JavaConnectionLogger *) MC_JAVA_NATIVE_INSTANCE->connectionLogger();
+    MC_SAFE_RELEASE(logger);
+    MC_JAVA_NATIVE_INSTANCE->setConnectionLogger(NULL);
+
+    jobject javaLogger = getObjectField(env, obj, "connectionLogger");
+    if (javaLogger != NULL) {
+        logger = new JavaConnectionLogger(env, javaLogger);
+        MC_JAVA_NATIVE_INSTANCE->setConnectionLogger(logger);
+    }
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IMAPSession.h b/src/java/native/com_libmailcore_IMAPSession.h
new file mode 100644
index 00000000..1096feae
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPSession.h
@@ -0,0 +1,597 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPSession */
+
+#ifndef _Included_com_libmailcore_IMAPSession
+#define _Included_com_libmailcore_IMAPSession
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    setHostname
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPSession_setHostname
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    hostname
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPSession_hostname
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    setPort
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPSession_setPort
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    port
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_libmailcore_IMAPSession_port
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    setUsername
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPSession_setUsername
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    username
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPSession_username
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    setPassword
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPSession_setPassword
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    password
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPSession_password
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    setOAuth2Token
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPSession_setOAuth2Token
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    OAuth2Token
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPSession_OAuth2Token
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    setAuthType
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPSession_setAuthType
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    authType
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_libmailcore_IMAPSession_authType
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    setConnectionType
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPSession_setConnectionType
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    connectionType
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_libmailcore_IMAPSession_connectionType
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    setTimeout
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPSession_setTimeout
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    timeout
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_libmailcore_IMAPSession_timeout
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    setCheckCertificateEnabled
+ * Signature: (Z)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPSession_setCheckCertificateEnabled
+  (JNIEnv *, jobject, jboolean);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    isCheckCertificateEnabled
+ * Signature: ()Z
+ */
+JNIEXPORT jboolean JNICALL Java_com_libmailcore_IMAPSession_isCheckCertificateEnabled
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    setDefaultNamespace
+ * Signature: (Lcom/libmailcore/IMAPNamespace;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPSession_setDefaultNamespace
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    defaultNamespace
+ * Signature: ()Lcom/libmailcore/IMAPNamespace;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_defaultNamespace
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    setAllowsFolderConcurrentAccessEnabled
+ * Signature: (Z)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPSession_setAllowsFolderConcurrentAccessEnabled
+  (JNIEnv *, jobject, jboolean);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    allowsFolderConcurrentAccessEnabled
+ * Signature: ()Z
+ */
+JNIEXPORT jboolean JNICALL Java_com_libmailcore_IMAPSession_allowsFolderConcurrentAccessEnabled
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    setMaximumConnections
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPSession_setMaximumConnections
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    maximumConnections
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_libmailcore_IMAPSession_maximumConnections
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    isOperationQueueRunning
+ * Signature: ()Z
+ */
+JNIEXPORT jboolean JNICALL Java_com_libmailcore_IMAPSession_isOperationQueueRunning
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    cancelAllOperations
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPSession_cancelAllOperations
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    serverIdentity
+ * Signature: ()Lcom/libmailcore/IMAPIdentity;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_serverIdentity
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    clientIdentity
+ * Signature: ()Lcom/libmailcore/IMAPIdentity;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_clientIdentity
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    gmailUserDisplayName
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_IMAPSession_gmailUserDisplayName
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    folderInfoOperation
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/IMAPFolderInfoOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_folderInfoOperation
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    folderStatusOperation
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/IMAPFolderStatusOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_folderStatusOperation
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    fetchSubscribedFoldersOperation
+ * Signature: ()Lcom/libmailcore/IMAPFetchFoldersOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_fetchSubscribedFoldersOperation
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    fetchAllFoldersOperation
+ * Signature: ()Lcom/libmailcore/IMAPFetchFoldersOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_fetchAllFoldersOperation
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    renameFolderOperation
+ * Signature: (Ljava/lang/String;Ljava/lang/String;)Lcom/libmailcore/IMAPOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_renameFolderOperation
+  (JNIEnv *, jobject, jstring, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    deleteFolderOperation
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/IMAPOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_deleteFolderOperation
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    createFolderOperation
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/IMAPOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_createFolderOperation
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    subscribeFolderOperation
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/IMAPOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_subscribeFolderOperation
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    unsubscribeFolderOperation
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/IMAPOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_unsubscribeFolderOperation
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    appendMessageOperation
+ * Signature: (Ljava/lang/String;[BILjava/util/List;)Lcom/libmailcore/IMAPAppendMessageOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_appendMessageOperation
+  (JNIEnv *, jobject, jstring, jbyteArray, jint, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    copyMessagesOperation
+ * Signature: (Ljava/lang/String;Lcom/libmailcore/IndexSet;Ljava/lang/String;)Lcom/libmailcore/IMAPCopyMessagesOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_copyMessagesOperation
+  (JNIEnv *, jobject, jstring, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    expungeOperation
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/IMAPOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_expungeOperation
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    fetchMessagesByUIDOperation
+ * Signature: (Ljava/lang/String;ILcom/libmailcore/IndexSet;)Lcom/libmailcore/IMAPFetchMessagesOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_fetchMessagesByUIDOperation
+  (JNIEnv *, jobject, jstring, jint, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    fetchMessagesByNumberOperation
+ * Signature: (Ljava/lang/String;ILcom/libmailcore/IndexSet;)Lcom/libmailcore/IMAPFetchMessagesOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_fetchMessagesByNumberOperation
+  (JNIEnv *, jobject, jstring, jint, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    syncMessagesByUIDOperation
+ * Signature: (Ljava/lang/String;ILcom/libmailcore/IndexSet;J)Lcom/libmailcore/IMAPFetchMessagesOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_syncMessagesByUIDOperation
+  (JNIEnv *, jobject, jstring, jint, jobject, jlong);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    fetchMessageByUIDOperation
+ * Signature: (Ljava/lang/String;JZ)Lcom/libmailcore/IMAPFetchContentOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_fetchMessageByUIDOperation
+  (JNIEnv *, jobject, jstring, jlong, jboolean);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    fetchMessageAttachmentByUIDOperation
+ * Signature: (Ljava/lang/String;JLjava/lang/String;IZ)Lcom/libmailcore/IMAPFetchContentOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_fetchMessageAttachmentByUIDOperation
+  (JNIEnv *, jobject, jstring, jlong, jstring, jint, jboolean);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    fetchMessageByNumberOperation
+ * Signature: (Ljava/lang/String;JZ)Lcom/libmailcore/IMAPFetchContentOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_fetchMessageByNumberOperation
+  (JNIEnv *, jobject, jstring, jlong, jboolean);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    fetchMessageAttachmentByNumberOperation
+ * Signature: (Ljava/lang/String;JLjava/lang/String;IZ)Lcom/libmailcore/IMAPFetchContentOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_fetchMessageAttachmentByNumberOperation
+  (JNIEnv *, jobject, jstring, jlong, jstring, jint, jboolean);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    fetchParsedMessageByUIDOperation
+ * Signature: (Ljava/lang/String;JZ)Lcom/libmailcore/IMAPFetchParsedContentOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_fetchParsedMessageByUIDOperation
+  (JNIEnv *, jobject, jstring, jlong, jboolean);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    fetchParsedMessageByNumberOperation
+ * Signature: (Ljava/lang/String;JZ)Lcom/libmailcore/IMAPFetchParsedContentOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_fetchParsedMessageByNumberOperation
+  (JNIEnv *, jobject, jstring, jlong, jboolean);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    storeFlagsByUIDOperation
+ * Signature: (Ljava/lang/String;Lcom/libmailcore/IndexSet;IILjava/util/List;)Lcom/libmailcore/IMAPOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_storeFlagsByUIDOperation
+  (JNIEnv *, jobject, jstring, jobject, jint, jint, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    storeFlagsByNumberOperation
+ * Signature: (Ljava/lang/String;Lcom/libmailcore/IndexSet;IILjava/util/List;)Lcom/libmailcore/IMAPOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_storeFlagsByNumberOperation
+  (JNIEnv *, jobject, jstring, jobject, jint, jint, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    storeLabelsByUIDOperation
+ * Signature: (Ljava/lang/String;Lcom/libmailcore/IndexSet;ILjava/util/List;)Lcom/libmailcore/IMAPOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_storeLabelsByUIDOperation
+  (JNIEnv *, jobject, jstring, jobject, jint, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    storeLabelsByNumberOperation
+ * Signature: (Ljava/lang/String;Lcom/libmailcore/IndexSet;ILjava/util/List;)Lcom/libmailcore/IMAPOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_storeLabelsByNumberOperation
+  (JNIEnv *, jobject, jstring, jobject, jint, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    searchOperation
+ * Signature: (Ljava/lang/String;ILjava/lang/String;)Lcom/libmailcore/IMAPSearchOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_searchOperation__Ljava_lang_String_2ILjava_lang_String_2
+  (JNIEnv *, jobject, jstring, jint, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    searchOperation
+ * Signature: (Ljava/lang/String;Lcom/libmailcore/IMAPSearchExpression;)Lcom/libmailcore/IMAPSearchOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_searchOperation__Ljava_lang_String_2Lcom_libmailcore_IMAPSearchExpression_2
+  (JNIEnv *, jobject, jstring, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    idleOperation
+ * Signature: (Ljava/lang/String;J)Lcom/libmailcore/IMAPIdleOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_idleOperation
+  (JNIEnv *, jobject, jstring, jlong);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    fetchNamespaceOperation
+ * Signature: ()Lcom/libmailcore/IMAPFetchNamespaceOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_fetchNamespaceOperation
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    identityOperation
+ * Signature: (Lcom/libmailcore/IMAPIdentity;)Lcom/libmailcore/IMAPIdentityOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_identityOperation
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    connectOperation
+ * Signature: ()Lcom/libmailcore/IMAPOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_connectOperation
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    checkAccountOperation
+ * Signature: ()Lcom/libmailcore/IMAPOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_checkAccountOperation
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    disconnectOperation
+ * Signature: ()Lcom/libmailcore/IMAPOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_disconnectOperation
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    capabilityOperation
+ * Signature: ()Lcom/libmailcore/IMAPCapabilityOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_capabilityOperation
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    quotaOperation
+ * Signature: ()Lcom/libmailcore/IMAPQuotaOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_quotaOperation
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    noopOperation
+ * Signature: ()Lcom/libmailcore/IMAPOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_noopOperation
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    htmlRenderingOperation
+ * Signature: (Lcom/libmailcore/IMAPMessage;Ljava/lang/String;)Lcom/libmailcore/IMAPMessageRenderingOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_htmlRenderingOperation
+  (JNIEnv *, jobject, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    htmlBodyRenderingOperation
+ * Signature: (Lcom/libmailcore/IMAPMessage;Ljava/lang/String;)Lcom/libmailcore/IMAPMessageRenderingOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_htmlBodyRenderingOperation
+  (JNIEnv *, jobject, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    plainTextRenderingOperation
+ * Signature: (Lcom/libmailcore/IMAPMessage;Ljava/lang/String;)Lcom/libmailcore/IMAPMessageRenderingOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_plainTextRenderingOperation
+  (JNIEnv *, jobject, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    plainTextBodyRenderingOperation
+ * Signature: (Lcom/libmailcore/IMAPMessage;Ljava/lang/String;Z)Lcom/libmailcore/IMAPMessageRenderingOperation;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IMAPSession_plainTextBodyRenderingOperation
+  (JNIEnv *, jobject, jobject, jstring, jboolean);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    setupNative
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPSession_setupNative
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    finalizeNative
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPSession_finalizeNative
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    setupNativeOperationQueueListener
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPSession_setupNativeOperationQueueListener
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IMAPSession
+ * Method:    setupNativeConnectionLogger
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IMAPSession_setupNativeConnectionLogger
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IMAPStoreFlagsRequestKind.h b/src/java/native/com_libmailcore_IMAPStoreFlagsRequestKind.h
new file mode 100644
index 00000000..602218a2
--- /dev/null
+++ b/src/java/native/com_libmailcore_IMAPStoreFlagsRequestKind.h
@@ -0,0 +1,19 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IMAPStoreFlagsRequestKind */
+
+#ifndef _Included_com_libmailcore_IMAPStoreFlagsRequestKind
+#define _Included_com_libmailcore_IMAPStoreFlagsRequestKind
+#ifdef __cplusplus
+extern "C" {
+#endif
+#undef com_libmailcore_IMAPStoreFlagsRequestKind_IMAPStoreFlagsRequestKindAdd
+#define com_libmailcore_IMAPStoreFlagsRequestKind_IMAPStoreFlagsRequestKindAdd 0L
+#undef com_libmailcore_IMAPStoreFlagsRequestKind_IMAPStoreFlagsRequestKindRemove
+#define com_libmailcore_IMAPStoreFlagsRequestKind_IMAPStoreFlagsRequestKindRemove 1L
+#undef com_libmailcore_IMAPStoreFlagsRequestKind_IMAPStoreFlagsRequestKindSet
+#define com_libmailcore_IMAPStoreFlagsRequestKind_IMAPStoreFlagsRequestKindSet 2L
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_IndexSet.cpp b/src/java/native/com_libmailcore_IndexSet.cpp
new file mode 100644
index 00000000..d38d9859
--- /dev/null
+++ b/src/java/native/com_libmailcore_IndexSet.cpp
@@ -0,0 +1,123 @@
+#include "com_libmailcore_IndexSet.h"
+
+#include "TypesUtils.h"
+#include "JavaHandle.h"
+#include "MCDefines.h"
+#include "MCIndexSet.h"
+
+using namespace mailcore;
+
+#define nativeType IndexSet
+#define javaType nativeType
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IndexSet_indexSet
+  (JNIEnv * env, jclass cls)
+{
+    return MC_TO_JAVA(IndexSet::indexSet());
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IndexSet_indexSetWithRange
+  (JNIEnv * env, jclass cls, jobject range)
+{
+    Range mcRange = rangeFromJava(env, range);
+    return MC_TO_JAVA(IndexSet::indexSetWithRange(mcRange));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IndexSet_indexSetWithIndex
+  (JNIEnv * env, jclass cls, jlong idx)
+{
+    return MC_TO_JAVA(IndexSet::indexSetWithIndex((uint64_t) idx));
+}
+
+JNIEXPORT jint JNICALL Java_com_libmailcore_IndexSet_count
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET_SCALAR(jint, count);
+}
+
+JNIEXPORT void JNICALL Java_com_libmailcore_IndexSet_addIndex
+  (JNIEnv * env, jobject obj, jlong idx)
+{
+    MC_JAVA_NATIVE_INSTANCE->addIndex((uint64_t) idx);
+}
+
+JNIEXPORT void JNICALL Java_com_libmailcore_IndexSet_removeIndex
+  (JNIEnv * env, jobject obj, jlong idx)
+{
+    MC_JAVA_NATIVE_INSTANCE->removeIndex((uint64_t) idx);
+}
+
+JNIEXPORT jboolean JNICALL Java_com_libmailcore_IndexSet_containsIndex
+  (JNIEnv * env, jobject obj, jlong idx)
+{
+    return (jboolean) MC_JAVA_NATIVE_INSTANCE->containsIndex((uint64_t) idx);
+}
+
+JNIEXPORT void JNICALL Java_com_libmailcore_IndexSet_addRange
+  (JNIEnv * env, jobject obj, jobject range)
+{
+    Range mcRange = rangeFromJava(env, range);
+    MC_JAVA_NATIVE_INSTANCE->addRange(mcRange);
+}
+
+JNIEXPORT void JNICALL Java_com_libmailcore_IndexSet_removeRange
+  (JNIEnv * env, jobject obj, jobject range)
+{
+    Range mcRange = rangeFromJava(env, range);
+    MC_JAVA_NATIVE_INSTANCE->removeRange(mcRange);
+}
+
+JNIEXPORT void JNICALL Java_com_libmailcore_IndexSet_intersectsRange
+  (JNIEnv * env, jobject obj, jobject range)
+{
+    Range mcRange = rangeFromJava(env, range);
+    MC_JAVA_NATIVE_INSTANCE->intersectsRange(mcRange);
+}
+
+JNIEXPORT void JNICALL Java_com_libmailcore_IndexSet_addIndexSet
+  (JNIEnv * env, jobject obj, jobject otherIndexSet)
+{
+    MC_JAVA_NATIVE_INSTANCE->addIndexSet(MC_FROM_JAVA(IndexSet, otherIndexSet));
+}
+
+JNIEXPORT void JNICALL Java_com_libmailcore_IndexSet_removeIndexSet
+  (JNIEnv * env, jobject obj, jobject otherIndexSet)
+{
+    MC_JAVA_NATIVE_INSTANCE->removeIndexSet(MC_FROM_JAVA(IndexSet, otherIndexSet));
+}
+
+JNIEXPORT void JNICALL Java_com_libmailcore_IndexSet_intersectsIndexSet
+  (JNIEnv * env, jobject obj, jobject otherIndexSet)
+{
+    MC_JAVA_NATIVE_INSTANCE->intersectsIndexSet(MC_FROM_JAVA(IndexSet, otherIndexSet));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IndexSet_allRanges
+  (JNIEnv * env, jobject obj)
+{
+    jclass cls = env->FindClass("java/util/Vector");
+    jmethodID constructor = env->GetMethodID(cls, "<init>", "(I)V");
+    unsigned int count = MC_JAVA_NATIVE_INSTANCE->rangesCount();
+    jobject javaVector = env->NewObject(cls, constructor, count);
+    jmethodID method = env->GetMethodID(cls, "add", "(Ljava.lang.Object;)Z");
+    Range * ranges = MC_JAVA_NATIVE_INSTANCE->allRanges();
+    for(unsigned int i = 0 ; i < count ; i ++) {
+        jobject javaObject = rangeToJava(env, ranges[i]);
+        env->CallBooleanMethod(javaVector, method, javaObject);
+    }
+    return javaVector;
+}
+
+JNIEXPORT jint JNICALL Java_com_libmailcore_IndexSet_rangesCount
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET_SCALAR(jint, rangesCount);
+}
+
+JNIEXPORT void JNICALL Java_com_libmailcore_IndexSet_removeAllIndexes
+  (JNIEnv * env, jobject obj)
+{
+    MC_JAVA_NATIVE_INSTANCE->removeAllIndexes();
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_IndexSet.h b/src/java/native/com_libmailcore_IndexSet.h
new file mode 100644
index 00000000..536caf53
--- /dev/null
+++ b/src/java/native/com_libmailcore_IndexSet.h
@@ -0,0 +1,149 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_IndexSet */
+
+#ifndef _Included_com_libmailcore_IndexSet
+#define _Included_com_libmailcore_IndexSet
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_IndexSet
+ * Method:    indexSet
+ * Signature: ()Lcom/libmailcore/IndexSet;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IndexSet_indexSet
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     com_libmailcore_IndexSet
+ * Method:    indexSetWithRange
+ * Signature: (Lcom/libmailcore/Range;)Lcom/libmailcore/IndexSet;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IndexSet_indexSetWithRange
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     com_libmailcore_IndexSet
+ * Method:    indexSetWithIndex
+ * Signature: (J)Lcom/libmailcore/IndexSet;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IndexSet_indexSetWithIndex
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     com_libmailcore_IndexSet
+ * Method:    count
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_libmailcore_IndexSet_count
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IndexSet
+ * Method:    addIndex
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IndexSet_addIndex
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_libmailcore_IndexSet
+ * Method:    removeIndex
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IndexSet_removeIndex
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_libmailcore_IndexSet
+ * Method:    containsIndex
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_com_libmailcore_IndexSet_containsIndex
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_libmailcore_IndexSet
+ * Method:    addRange
+ * Signature: (Lcom/libmailcore/Range;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IndexSet_addRange
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_IndexSet
+ * Method:    removeRange
+ * Signature: (Lcom/libmailcore/Range;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IndexSet_removeRange
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_IndexSet
+ * Method:    intersectsRange
+ * Signature: (Lcom/libmailcore/Range;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IndexSet_intersectsRange
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_IndexSet
+ * Method:    addIndexSet
+ * Signature: (Lcom/libmailcore/IndexSet;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IndexSet_addIndexSet
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_IndexSet
+ * Method:    removeIndexSet
+ * Signature: (Lcom/libmailcore/IndexSet;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IndexSet_removeIndexSet
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_IndexSet
+ * Method:    intersectsIndexSet
+ * Signature: (Lcom/libmailcore/IndexSet;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IndexSet_intersectsIndexSet
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_IndexSet
+ * Method:    allRanges
+ * Signature: ()Ljava/util/List;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_IndexSet_allRanges
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IndexSet
+ * Method:    rangesCount
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_libmailcore_IndexSet_rangesCount
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IndexSet
+ * Method:    removeAllIndexes
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IndexSet_removeAllIndexes
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_IndexSet
+ * Method:    setupNative
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_IndexSet_setupNative
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_MailException.h b/src/java/native/com_libmailcore_MailException.h
new file mode 100644
index 00000000..6215d31e
--- /dev/null
+++ b/src/java/native/com_libmailcore_MailException.h
@@ -0,0 +1,103 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_MailException */
+
+#ifndef _Included_com_libmailcore_MailException
+#define _Included_com_libmailcore_MailException
+#ifdef __cplusplus
+extern "C" {
+#endif
+#undef com_libmailcore_MailException_serialVersionUID
+#define com_libmailcore_MailException_serialVersionUID -3042686055658047285LL
+#undef com_libmailcore_MailException_serialVersionUID
+#define com_libmailcore_MailException_serialVersionUID -3387516993124229948LL
+#undef com_libmailcore_MailException_ERROR_NONE
+#define com_libmailcore_MailException_ERROR_NONE 0L
+#undef com_libmailcore_MailException_ERROR_CONNECTION
+#define com_libmailcore_MailException_ERROR_CONNECTION 1L
+#undef com_libmailcore_MailException_ERROR_TLS_NOT_AVAILABLE
+#define com_libmailcore_MailException_ERROR_TLS_NOT_AVAILABLE 2L
+#undef com_libmailcore_MailException_ERROR_PARSE
+#define com_libmailcore_MailException_ERROR_PARSE 3L
+#undef com_libmailcore_MailException_ERROR_CERTIFICATE
+#define com_libmailcore_MailException_ERROR_CERTIFICATE 4L
+#undef com_libmailcore_MailException_ERROR_AUTHENTICATION
+#define com_libmailcore_MailException_ERROR_AUTHENTICATION 5L
+#undef com_libmailcore_MailException_ERROR_GMAIL_IMAP_NOT_ENABLED
+#define com_libmailcore_MailException_ERROR_GMAIL_IMAP_NOT_ENABLED 6L
+#undef com_libmailcore_MailException_ERROR_GMAIL_EXCEED_BANDWIDTH_LIMIT
+#define com_libmailcore_MailException_ERROR_GMAIL_EXCEED_BANDWIDTH_LIMIT 7L
+#undef com_libmailcore_MailException_ERROR_GMAIL_TOO_MANY_SIMULTANEOUS_CONNECTIONS
+#define com_libmailcore_MailException_ERROR_GMAIL_TOO_MANY_SIMULTANEOUS_CONNECTIONS 8L
+#undef com_libmailcore_MailException_ERROR_MOBILEME_MOVED
+#define com_libmailcore_MailException_ERROR_MOBILEME_MOVED 9L
+#undef com_libmailcore_MailException_ERROR_YAHOO_UNAVAILABLE
+#define com_libmailcore_MailException_ERROR_YAHOO_UNAVAILABLE 10L
+#undef com_libmailcore_MailException_ERROR_NON_EXISTANT_FOLDER
+#define com_libmailcore_MailException_ERROR_NON_EXISTANT_FOLDER 11L
+#undef com_libmailcore_MailException_ERROR_RENAME
+#define com_libmailcore_MailException_ERROR_RENAME 12L
+#undef com_libmailcore_MailException_ERROR_DELETE
+#define com_libmailcore_MailException_ERROR_DELETE 13L
+#undef com_libmailcore_MailException_ERROR_CREATE
+#define com_libmailcore_MailException_ERROR_CREATE 14L
+#undef com_libmailcore_MailException_ERROR_SUBSCRIBED
+#define com_libmailcore_MailException_ERROR_SUBSCRIBED 15L
+#undef com_libmailcore_MailException_ERROR_APPEND
+#define com_libmailcore_MailException_ERROR_APPEND 16L
+#undef com_libmailcore_MailException_ERROR_COPY
+#define com_libmailcore_MailException_ERROR_COPY 17L
+#undef com_libmailcore_MailException_ERROR_EXPUNGE
+#define com_libmailcore_MailException_ERROR_EXPUNGE 18L
+#undef com_libmailcore_MailException_ERROR_FETCH
+#define com_libmailcore_MailException_ERROR_FETCH 19L
+#undef com_libmailcore_MailException_ERROR_IDLE
+#define com_libmailcore_MailException_ERROR_IDLE 20L
+#undef com_libmailcore_MailException_ERROR_IDENTITY
+#define com_libmailcore_MailException_ERROR_IDENTITY 21L
+#undef com_libmailcore_MailException_ERROR_NAMESPACE
+#define com_libmailcore_MailException_ERROR_NAMESPACE 22L
+#undef com_libmailcore_MailException_ERROR_STORE
+#define com_libmailcore_MailException_ERROR_STORE 23L
+#undef com_libmailcore_MailException_ERROR_CAPABILITY
+#define com_libmailcore_MailException_ERROR_CAPABILITY 24L
+#undef com_libmailcore_MailException_ERROR_STARTTLS_NOT_AVAILABLE
+#define com_libmailcore_MailException_ERROR_STARTTLS_NOT_AVAILABLE 25L
+#undef com_libmailcore_MailException_ERROR_SEND_MESSAGE_ILLEGAL_ATTACHMENT
+#define com_libmailcore_MailException_ERROR_SEND_MESSAGE_ILLEGAL_ATTACHMENT 26L
+#undef com_libmailcore_MailException_ERROR_STORAGE_LIMIT
+#define com_libmailcore_MailException_ERROR_STORAGE_LIMIT 27L
+#undef com_libmailcore_MailException_ERROR_SEND_MESSAGE_NOT_ALLOWED
+#define com_libmailcore_MailException_ERROR_SEND_MESSAGE_NOT_ALLOWED 28L
+#undef com_libmailcore_MailException_ERROR_NEEDS_CONNECT_TO_WEBMAIL
+#define com_libmailcore_MailException_ERROR_NEEDS_CONNECT_TO_WEBMAIL 29L
+#undef com_libmailcore_MailException_ERROR_SEND_MESSAGE
+#define com_libmailcore_MailException_ERROR_SEND_MESSAGE 30L
+#undef com_libmailcore_MailException_ERROR_AUTHENTICATION_REQUIRED
+#define com_libmailcore_MailException_ERROR_AUTHENTICATION_REQUIRED 31L
+#undef com_libmailcore_MailException_ERROR_FETCH_MESSAGE_LIST
+#define com_libmailcore_MailException_ERROR_FETCH_MESSAGE_LIST 32L
+#undef com_libmailcore_MailException_ERROR_DELETE_MESSAGE
+#define com_libmailcore_MailException_ERROR_DELETE_MESSAGE 33L
+#undef com_libmailcore_MailException_ERROR_INVALID_ACCOUNT
+#define com_libmailcore_MailException_ERROR_INVALID_ACCOUNT 34L
+#undef com_libmailcore_MailException_ERROR_FILE
+#define com_libmailcore_MailException_ERROR_FILE 35L
+#undef com_libmailcore_MailException_ERROR_COMPRESSION
+#define com_libmailcore_MailException_ERROR_COMPRESSION 36L
+#undef com_libmailcore_MailException_ERROR_NO_SENDER
+#define com_libmailcore_MailException_ERROR_NO_SENDER 37L
+#undef com_libmailcore_MailException_ERROR_NO_RECIPIENT
+#define com_libmailcore_MailException_ERROR_NO_RECIPIENT 38L
+#undef com_libmailcore_MailException_ERROR_NOOP
+#define com_libmailcore_MailException_ERROR_NOOP 39L
+#undef com_libmailcore_MailException_ERROR_GMAIL_APPLICATION_SPECIFIC_PASSWORD_REQUIRED
+#define com_libmailcore_MailException_ERROR_GMAIL_APPLICATION_SPECIFIC_PASSWORD_REQUIRED 40L
+#undef com_libmailcore_MailException_ERROR_SERVER_DATE
+#define com_libmailcore_MailException_ERROR_SERVER_DATE 41L
+#undef com_libmailcore_MailException_ERROR_COUNT
+#define com_libmailcore_MailException_ERROR_COUNT 42L
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_MainThreadUtils.h b/src/java/native/com_libmailcore_MainThreadUtils.h
new file mode 100644
index 00000000..327d9910
--- /dev/null
+++ b/src/java/native/com_libmailcore_MainThreadUtils.h
@@ -0,0 +1,37 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_MainThreadUtils */
+
+#ifndef _Included_com_libmailcore_MainThreadUtils
+#define _Included_com_libmailcore_MainThreadUtils
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_MainThreadUtils
+ * Method:    setupNative
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MainThreadUtils_setupNative
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MainThreadUtils
+ * Method:    runIdentifier
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MainThreadUtils_runIdentifier
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_libmailcore_MainThreadUtils
+ * Method:    runIdentifierAndNotify
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MainThreadUtils_runIdentifierAndNotify
+  (JNIEnv *, jobject, jlong);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_MessageBuilder.cpp b/src/java/native/com_libmailcore_MessageBuilder.cpp
new file mode 100644
index 00000000..4369f436
--- /dev/null
+++ b/src/java/native/com_libmailcore_MessageBuilder.cpp
@@ -0,0 +1,90 @@
+#include "com_libmailcore_MessageBuilder.h"
+
+#include "TypesUtils.h"
+#include "JavaHandle.h"
+#include "MCMessageBuilder.h"
+#include "MCDefines.h"
+#include "JavaHTMLRendererTemplateCallback.h"
+
+using namespace mailcore;
+
+#define nativeType MessageBuilder
+#define javaType nativeType
+
+MC_JAVA_SYNTHESIZE_STRING(setHTMLBody, htmlBody)
+MC_JAVA_SYNTHESIZE_STRING(setTextBody, textBody)
+MC_JAVA_SYNTHESIZE(Array, setAttachments, attachments)
+
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageBuilder_addAttachment
+    (JNIEnv * env, jobject obj, jobject attachment)
+{
+    MC_JAVA_NATIVE_INSTANCE->addAttachment(MC_FROM_JAVA(Attachment, attachment));
+}
+
+MC_JAVA_SYNTHESIZE(Array, setRelatedAttachments, relatedAttachments)
+
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageBuilder_addRelatedAttachment
+    (JNIEnv * env, jobject obj, jobject attachment)
+{
+    MC_JAVA_NATIVE_INSTANCE->addRelatedAttachment(MC_FROM_JAVA(Attachment, attachment));
+}
+
+MC_JAVA_SYNTHESIZE_STRING(setBoundaryPrefix, boundaryPrefix)
+
+JNIEXPORT jbyteArray JNICALL Java_com_libmailcore_MessageBuilder_data
+    (JNIEnv * env, jobject obj)
+{
+    return (jbyteArray) MC_JAVA_BRIDGE_GET(data);
+}
+
+JNIEXPORT jbyteArray JNICALL Java_com_libmailcore_MessageBuilder_dataForEncryption
+    (JNIEnv * env, jobject obj)
+{
+    return (jbyteArray) MC_JAVA_BRIDGE_GET(dataForEncryption);
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_MessageBuilder_htmlRendering
+    (JNIEnv * env, jobject obj, jobject javaCallback)
+{
+    JavaHTMLRendererTemplateCallback * callback = NULL;
+    if (javaCallback != NULL) {
+        callback = new JavaHTMLRendererTemplateCallback(env, javaCallback);
+    }
+    jstring result = (jstring) MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->htmlRendering(callback));
+    if (callback != NULL) {
+        delete callback;
+    }
+    return result;
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_MessageBuilder_htmlBodyRendering
+    (JNIEnv * env, jobject obj)
+{
+    return (jstring) MC_JAVA_BRIDGE_GET(htmlBodyRendering);
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_MessageBuilder_plainTextRendering
+    (JNIEnv * env, jobject obj)
+{
+    return (jstring) MC_JAVA_NATIVE_INSTANCE->plainTextRendering();
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_MessageBuilder_plainTextBodyRendering
+    (JNIEnv * env, jobject obj, jboolean stripWhitespace)
+{
+    return (jstring) MC_JAVA_NATIVE_INSTANCE->plainTextBodyRendering((bool) stripWhitespace);
+}
+
+JNIEXPORT jbyteArray JNICALL Java_com_libmailcore_MessageBuilder_openPGPSignedMessageDataWithSignatureData
+    (JNIEnv * env, jobject obj, jbyteArray signature)
+{
+    return (jbyteArray) MC_JAVA_NATIVE_INSTANCE->openPGPSignedMessageDataWithSignatureData(MC_FROM_JAVA(Data, signature));
+}
+
+JNIEXPORT jbyteArray JNICALL Java_com_libmailcore_MessageBuilder_openPGPEncryptedMessageDataWithEncryptedData
+    (JNIEnv * env, jobject obj, jbyteArray encryptedData)
+{
+    return (jbyteArray) MC_JAVA_NATIVE_INSTANCE->openPGPEncryptedMessageDataWithEncryptedData(MC_FROM_JAVA(Data, encryptedData));
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_MessageBuilder.h b/src/java/native/com_libmailcore_MessageBuilder.h
new file mode 100644
index 00000000..e57f235c
--- /dev/null
+++ b/src/java/native/com_libmailcore_MessageBuilder.h
@@ -0,0 +1,181 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_MessageBuilder */
+
+#ifndef _Included_com_libmailcore_MessageBuilder
+#define _Included_com_libmailcore_MessageBuilder
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_MessageBuilder
+ * Method:    setHTMLBody
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageBuilder_setHTMLBody
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_MessageBuilder
+ * Method:    htmlBody
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_MessageBuilder_htmlBody
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageBuilder
+ * Method:    setTextBody
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageBuilder_setTextBody
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_MessageBuilder
+ * Method:    textBody
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_MessageBuilder_textBody
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageBuilder
+ * Method:    setAttachments
+ * Signature: (Ljava/util/List;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageBuilder_setAttachments
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageBuilder
+ * Method:    attachments
+ * Signature: ()Ljava/util/List;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_MessageBuilder_attachments
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageBuilder
+ * Method:    addAttachment
+ * Signature: (Lcom/libmailcore/Attachment;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageBuilder_addAttachment
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageBuilder
+ * Method:    setRelatedAttachments
+ * Signature: (Ljava/util/List;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageBuilder_setRelatedAttachments
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageBuilder
+ * Method:    relatedAttachments
+ * Signature: ()Ljava/util/List;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_MessageBuilder_relatedAttachments
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageBuilder
+ * Method:    addRelatedAttachment
+ * Signature: (Lcom/libmailcore/Attachment;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageBuilder_addRelatedAttachment
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageBuilder
+ * Method:    setBoundaryPrefix
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageBuilder_setBoundaryPrefix
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_MessageBuilder
+ * Method:    boundaryPrefix
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_MessageBuilder_boundaryPrefix
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageBuilder
+ * Method:    data
+ * Signature: ()[B
+ */
+JNIEXPORT jbyteArray JNICALL Java_com_libmailcore_MessageBuilder_data
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageBuilder
+ * Method:    dataForEncryption
+ * Signature: ()[B
+ */
+JNIEXPORT jbyteArray JNICALL Java_com_libmailcore_MessageBuilder_dataForEncryption
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageBuilder
+ * Method:    htmlRendering
+ * Signature: (Lcom/libmailcore/HTMLRendererTemplateCallback;)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_MessageBuilder_htmlRendering
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageBuilder
+ * Method:    htmlBodyRendering
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_MessageBuilder_htmlBodyRendering
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageBuilder
+ * Method:    plainTextRendering
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_MessageBuilder_plainTextRendering
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageBuilder
+ * Method:    plainTextBodyRendering
+ * Signature: (Z)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_MessageBuilder_plainTextBodyRendering
+  (JNIEnv *, jobject, jboolean);
+
+/*
+ * Class:     com_libmailcore_MessageBuilder
+ * Method:    openPGPSignedMessageDataWithSignatureData
+ * Signature: ([B)[B
+ */
+JNIEXPORT jbyteArray JNICALL Java_com_libmailcore_MessageBuilder_openPGPSignedMessageDataWithSignatureData
+  (JNIEnv *, jobject, jbyteArray);
+
+/*
+ * Class:     com_libmailcore_MessageBuilder
+ * Method:    openPGPEncryptedMessageDataWithEncryptedData
+ * Signature: ([B)[B
+ */
+JNIEXPORT jbyteArray JNICALL Java_com_libmailcore_MessageBuilder_openPGPEncryptedMessageDataWithEncryptedData
+  (JNIEnv *, jobject, jbyteArray);
+
+/*
+ * Class:     com_libmailcore_MessageBuilder
+ * Method:    setupNative
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageBuilder_setupNative
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_MessageFlag.h b/src/java/native/com_libmailcore_MessageFlag.h
new file mode 100644
index 00000000..8e6354d8
--- /dev/null
+++ b/src/java/native/com_libmailcore_MessageFlag.h
@@ -0,0 +1,35 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_MessageFlag */
+
+#ifndef _Included_com_libmailcore_MessageFlag
+#define _Included_com_libmailcore_MessageFlag
+#ifdef __cplusplus
+extern "C" {
+#endif
+#undef com_libmailcore_MessageFlag_MessageFlagNone
+#define com_libmailcore_MessageFlag_MessageFlagNone 0L
+#undef com_libmailcore_MessageFlag_MessageFlagSeen
+#define com_libmailcore_MessageFlag_MessageFlagSeen 1L
+#undef com_libmailcore_MessageFlag_MessageFlagAnswered
+#define com_libmailcore_MessageFlag_MessageFlagAnswered 2L
+#undef com_libmailcore_MessageFlag_MessageFlagFlagged
+#define com_libmailcore_MessageFlag_MessageFlagFlagged 4L
+#undef com_libmailcore_MessageFlag_MessageFlagDeleted
+#define com_libmailcore_MessageFlag_MessageFlagDeleted 8L
+#undef com_libmailcore_MessageFlag_MessageFlagDraft
+#define com_libmailcore_MessageFlag_MessageFlagDraft 16L
+#undef com_libmailcore_MessageFlag_MessageFlagMDNSent
+#define com_libmailcore_MessageFlag_MessageFlagMDNSent 32L
+#undef com_libmailcore_MessageFlag_MessageFlagForwarded
+#define com_libmailcore_MessageFlag_MessageFlagForwarded 64L
+#undef com_libmailcore_MessageFlag_MessageFlagSubmitPending
+#define com_libmailcore_MessageFlag_MessageFlagSubmitPending 128L
+#undef com_libmailcore_MessageFlag_MessageFlagSubmitted
+#define com_libmailcore_MessageFlag_MessageFlagSubmitted 256L
+#undef com_libmailcore_MessageFlag_MessageFlagMaskAll
+#define com_libmailcore_MessageFlag_MessageFlagMaskAll 511L
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_MessageHeader.cpp b/src/java/native/com_libmailcore_MessageHeader.cpp
new file mode 100644
index 00000000..9fc61d93
--- /dev/null
+++ b/src/java/native/com_libmailcore_MessageHeader.cpp
@@ -0,0 +1,111 @@
+#include "com_libmailcore_Address.h"
+
+#include "TypesUtils.h"
+#include "JavaHandle.h"
+#include "MCMessageHeader.h"
+#include "MCDefines.h"
+
+using namespace mailcore;
+
+#define nativeType MessageHeader
+#define javaType nativeType
+
+MC_JAVA_SYNTHESIZE_STRING(setMessageID, messageID)
+
+JNIEXPORT jboolean JNICALL Java_com_libmailcore_MessageHeader_isMessageIDAutoGenerated
+  (JNIEnv * env, jobject obj)
+{
+    return (jboolean) MC_JAVA_NATIVE_INSTANCE->isMessageIDAutoGenerated();
+}
+
+MC_JAVA_SYNTHESIZE(Array, setReferences, references)
+MC_JAVA_SYNTHESIZE(Array, setInReplyTo, inReplyTo)
+    
+JNIEXPORT jobject JNICALL Java_com_libmailcore_MessageHeader_date
+  (JNIEnv * env, jobject obj)
+{
+    return timeToJavaDate(env, MC_JAVA_NATIVE_INSTANCE->date());
+}
+
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageHeader_setDate
+  (JNIEnv * env, jobject obj, jobject date)
+{
+    MC_JAVA_NATIVE_INSTANCE->setDate(javaDateToTime(env, date));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_MessageHeader_receivedDate
+  (JNIEnv * env, jobject obj)
+{
+    return timeToJavaDate(env, MC_JAVA_NATIVE_INSTANCE->receivedDate());
+}
+
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageHeader_setReceivedDate
+  (JNIEnv * env, jobject obj, jobject date)
+{
+    MC_JAVA_NATIVE_INSTANCE->setReceivedDate(javaDateToTime(env, date));
+}
+
+MC_JAVA_SYNTHESIZE(Address, setSender, sender)
+MC_JAVA_SYNTHESIZE(Address, setFrom, from)
+MC_JAVA_SYNTHESIZE(Array, setTo, to)
+MC_JAVA_SYNTHESIZE(Array, setCc, cc)
+MC_JAVA_SYNTHESIZE(Array, setBcc, bcc)
+MC_JAVA_SYNTHESIZE(Array, setReplyTo, replyTo)
+MC_JAVA_SYNTHESIZE_STRING(setSubject, subject)
+MC_JAVA_SYNTHESIZE_STRING(setUserAgent, userAgent)
+
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageHeader_setExtraHeader
+  (JNIEnv * env, jobject obj, jstring name, jstring value)
+{
+    MC_JAVA_NATIVE_INSTANCE->setExtraHeader(MC_FROM_JAVA(String, name), MC_FROM_JAVA(String, value));
+}
+
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageHeader_removeExtraHeader
+  (JNIEnv * env, jobject obj, jstring name)
+{
+    MC_JAVA_NATIVE_INSTANCE->removeExtraHeader(MC_FROM_JAVA(String, name));
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_MessageHeader_extraHeaderValueForName
+  (JNIEnv * env, jobject obj, jstring name)
+{
+    return (jstring) MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->extraHeaderValueForName(MC_FROM_JAVA(String, name)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_MessageHeader_allExtraHeadersNames
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET(allExtraHeadersNames);
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_MessageHeader_extractedSubject
+  (JNIEnv * env, jobject obj)
+{
+    return (jstring) MC_JAVA_BRIDGE_GET(extractedSubject);
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_MessageHeader_partialExtractedSubject
+  (JNIEnv * env, jobject obj)
+{
+    return (jstring) MC_JAVA_BRIDGE_GET(partialExtractedSubject);
+}
+
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageHeader_importHeadersData
+  (JNIEnv * env, jobject obj, jbyteArray data)
+{
+    MC_JAVA_NATIVE_INSTANCE->importHeadersData(MC_FROM_JAVA(Data, data));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_MessageHeader_replyHeader
+  (JNIEnv * env, jobject obj, jboolean replyAll, jobject excludedRecipients)
+{
+    return MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->replyHeader(replyAll, MC_FROM_JAVA(Array, excludedRecipients)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_MessageHeader_forwardHeader
+  (JNIEnv * env, jobject obj)
+{
+    return (jstring) MC_JAVA_BRIDGE_GET(forwardHeader);
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_MessageHeader.h b/src/java/native/com_libmailcore_MessageHeader.h
new file mode 100644
index 00000000..0a40c0c8
--- /dev/null
+++ b/src/java/native/com_libmailcore_MessageHeader.h
@@ -0,0 +1,309 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_MessageHeader */
+
+#ifndef _Included_com_libmailcore_MessageHeader
+#define _Included_com_libmailcore_MessageHeader
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    messageID
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_MessageHeader_messageID
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    setMessageID
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageHeader_setMessageID
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    isMessageIDAutoGenerated
+ * Signature: ()Z
+ */
+JNIEXPORT jboolean JNICALL Java_com_libmailcore_MessageHeader_isMessageIDAutoGenerated
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    references
+ * Signature: ()Ljava/util/List;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_MessageHeader_references
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    setReferences
+ * Signature: (Ljava/util/List;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageHeader_setReferences
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    inReplyTo
+ * Signature: ()Ljava/util/List;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_MessageHeader_inReplyTo
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    setInReplyTo
+ * Signature: (Ljava/util/List;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageHeader_setInReplyTo
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    date
+ * Signature: ()Ljava/util/Date;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_MessageHeader_date
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    setDate
+ * Signature: (Ljava/util/Date;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageHeader_setDate
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    receivedDate
+ * Signature: ()Ljava/util/Date;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_MessageHeader_receivedDate
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    setReceivedDate
+ * Signature: (Ljava/util/Date;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageHeader_setReceivedDate
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    sender
+ * Signature: ()Lcom/libmailcore/Address;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_MessageHeader_sender
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    setSender
+ * Signature: (Lcom/libmailcore/Address;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageHeader_setSender
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    from
+ * Signature: ()Lcom/libmailcore/Address;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_MessageHeader_from
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    setFrom
+ * Signature: (Lcom/libmailcore/Address;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageHeader_setFrom
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    to
+ * Signature: ()Ljava/util/List;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_MessageHeader_to
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    setTo
+ * Signature: (Ljava/util/List;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageHeader_setTo
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    cc
+ * Signature: ()Ljava/util/List;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_MessageHeader_cc
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    setCc
+ * Signature: (Ljava/util/List;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageHeader_setCc
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    bcc
+ * Signature: ()Ljava/util/List;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_MessageHeader_bcc
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    setBcc
+ * Signature: (Ljava/util/List;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageHeader_setBcc
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    replyTo
+ * Signature: ()Ljava/util/List;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_MessageHeader_replyTo
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    setReplyTo
+ * Signature: (Ljava/util/List;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageHeader_setReplyTo
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    subject
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_MessageHeader_subject
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    setSubject
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageHeader_setSubject
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    userAgent
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_MessageHeader_userAgent
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    setUserAgent
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageHeader_setUserAgent
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    setExtraHeader
+ * Signature: (Ljava/lang/String;Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageHeader_setExtraHeader
+  (JNIEnv *, jobject, jstring, jstring);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    removeExtraHeader
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageHeader_removeExtraHeader
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    extraHeaderValueForName
+ * Signature: (Ljava/lang/String;)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_MessageHeader_extraHeaderValueForName
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    allExtraHeadersNames
+ * Signature: ()Ljava/util/List;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_MessageHeader_allExtraHeadersNames
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    extractedSubject
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_MessageHeader_extractedSubject
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    partialExtractedSubject
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_MessageHeader_partialExtractedSubject
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    importHeadersData
+ * Signature: ([B)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageHeader_importHeadersData
+  (JNIEnv *, jobject, jbyteArray);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    replyHeader
+ * Signature: (ZLjava/util/List;)Lcom/libmailcore/MessageHeader;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_MessageHeader_replyHeader
+  (JNIEnv *, jobject, jboolean, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    forwardHeader
+ * Signature: ()Lcom/libmailcore/MessageHeader;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_MessageHeader_forwardHeader
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageHeader
+ * Method:    setupNative
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageHeader_setupNative
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_MessageParser.cpp b/src/java/native/com_libmailcore_MessageParser.cpp
new file mode 100644
index 00000000..8bdec7fd
--- /dev/null
+++ b/src/java/native/com_libmailcore_MessageParser.cpp
@@ -0,0 +1,70 @@
+#include "com_libmailcore_MessageParser.h"
+
+#include "TypesUtils.h"
+#include "JavaHandle.h"
+#include "MCMessageParser.h"
+#include "MCDefines.h"
+#include "JavaHTMLRendererTemplateCallback.h"
+
+using namespace mailcore;
+
+#define nativeType MessageParser
+#define javaType nativeType
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_MessageParser_messageParserWithData
+  (JNIEnv * env, jclass cls, jbyteArray data)
+{
+    return MC_TO_JAVA(MessageParser::messageParserWithData(MC_FROM_JAVA(Data, data)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_MessageParser_messageParserWithContentsOfFile
+  (JNIEnv * env, jclass cls, jstring filename)
+{
+    return MC_TO_JAVA(MessageParser::messageParserWithContentsOfFile(MC_FROM_JAVA(String, filename)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_MessageParser_mainPart
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET(mainPart);
+}
+
+JNIEXPORT jbyteArray JNICALL Java_com_libmailcore_MessageParser_data
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET_DATA(data);
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_MessageParser_htmlRendering
+  (JNIEnv * env, jobject obj, jobject javaCallback)
+{
+    JavaHTMLRendererTemplateCallback * callback = NULL;
+    if (javaCallback != NULL) {
+        callback = new JavaHTMLRendererTemplateCallback(env, javaCallback);
+    }
+    jstring result = (jstring) MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->htmlRendering(callback));
+    if (callback != NULL) {
+        delete callback;
+    }
+    return result;
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_MessageParser_htmlBodyRendering
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET_STRING(htmlBodyRendering);
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_MessageParser_plainTextRendering
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET_STRING(plainTextRendering);
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_MessageParser_plainTextBodyRendering
+  (JNIEnv * env, jobject obj, jboolean stripWhitespace)
+{
+    return (jstring) MC_TO_JAVA(MC_JAVA_NATIVE_INSTANCE->plainTextBodyRendering((bool) stripWhitespace));
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_MessageParser.h b/src/java/native/com_libmailcore_MessageParser.h
new file mode 100644
index 00000000..ba6098eb
--- /dev/null
+++ b/src/java/native/com_libmailcore_MessageParser.h
@@ -0,0 +1,85 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_MessageParser */
+
+#ifndef _Included_com_libmailcore_MessageParser
+#define _Included_com_libmailcore_MessageParser
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_MessageParser
+ * Method:    messageParserWithData
+ * Signature: ([B)Lcom/libmailcore/MessageParser;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_MessageParser_messageParserWithData
+  (JNIEnv *, jclass, jbyteArray);
+
+/*
+ * Class:     com_libmailcore_MessageParser
+ * Method:    messageParserWithContentsOfFile
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/MessageParser;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_MessageParser_messageParserWithContentsOfFile
+  (JNIEnv *, jclass, jstring);
+
+/*
+ * Class:     com_libmailcore_MessageParser
+ * Method:    mainPart
+ * Signature: ()Lcom/libmailcore/AbstractPart;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_MessageParser_mainPart
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageParser
+ * Method:    data
+ * Signature: ()[B
+ */
+JNIEXPORT jbyteArray JNICALL Java_com_libmailcore_MessageParser_data
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageParser
+ * Method:    htmlRendering
+ * Signature: (Lcom/libmailcore/HTMLRendererTemplateCallback;)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_MessageParser_htmlRendering
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageParser
+ * Method:    htmlBodyRendering
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_MessageParser_htmlBodyRendering
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageParser
+ * Method:    plainTextRendering
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_MessageParser_plainTextRendering
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_MessageParser
+ * Method:    plainTextBodyRendering
+ * Signature: (Z)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_MessageParser_plainTextBodyRendering
+  (JNIEnv *, jobject, jboolean);
+
+/*
+ * Class:     com_libmailcore_MessageParser
+ * Method:    setupNative
+ * Signature: ([B)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_MessageParser_setupNative
+  (JNIEnv *, jobject, jbyteArray);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_MessagePart.cpp b/src/java/native/com_libmailcore_MessagePart.cpp
new file mode 100644
index 00000000..90a5e5b8
--- /dev/null
+++ b/src/java/native/com_libmailcore_MessagePart.cpp
@@ -0,0 +1,13 @@
+#include "com_libmailcore_MessageParser.h"
+
+#include "TypesUtils.h"
+#include "JavaHandle.h"
+#include "MCMessagePart.h"
+#include "MCDefines.h"
+
+using namespace mailcore;
+
+#define nativeType MessagePart
+#define javaType nativeType
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_MessagePart.h b/src/java/native/com_libmailcore_MessagePart.h
new file mode 100644
index 00000000..3067f720
--- /dev/null
+++ b/src/java/native/com_libmailcore_MessagePart.h
@@ -0,0 +1,13 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_MessagePart */
+
+#ifndef _Included_com_libmailcore_MessagePart
+#define _Included_com_libmailcore_MessagePart
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_Multipart.cpp b/src/java/native/com_libmailcore_Multipart.cpp
new file mode 100644
index 00000000..5169e1fd
--- /dev/null
+++ b/src/java/native/com_libmailcore_Multipart.cpp
@@ -0,0 +1,13 @@
+#include "com_libmailcore_Multipart.h"
+
+#include "TypesUtils.h"
+#include "JavaHandle.h"
+#include "MCMultipart.h"
+#include "MCDefines.h"
+
+using namespace mailcore;
+
+#define nativeType Multipart
+#define javaType nativeType
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_Multipart.h b/src/java/native/com_libmailcore_Multipart.h
new file mode 100644
index 00000000..0ab64d29
--- /dev/null
+++ b/src/java/native/com_libmailcore_Multipart.h
@@ -0,0 +1,13 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_Multipart */
+
+#ifndef _Included_com_libmailcore_Multipart
+#define _Included_com_libmailcore_Multipart
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_NativeObject.cpp b/src/java/native/com_libmailcore_NativeObject.cpp
new file mode 100644
index 00000000..643964ea
--- /dev/null
+++ b/src/java/native/com_libmailcore_NativeObject.cpp
@@ -0,0 +1,53 @@
+#include "com_libmailcore_NativeObject.h"
+
+#include "MCBaseTypes.h"
+#include "JavaHandle.h"
+#include "TypesUtils.h"
+
+using namespace mailcore;
+
+JNIEXPORT void JNICALL Java_com_libmailcore_NativeObject_initWithNative
+  (JNIEnv * env, jobject obj, jlong nativeHandle)
+{
+    setHandle(env, obj, (void *) nativeHandle);
+    Object * mcObject = (Object *) nativeHandle;
+    MC_SAFE_RETAIN(mcObject);
+}
+
+JNIEXPORT void JNICALL Java_com_libmailcore_NativeObject_unsetupNative
+  (JNIEnv * env, jobject obj)
+{
+    Object * mcObj = (Object *) getHandle(env, obj);
+    MC_SAFE_RELEASE(mcObj);
+    setHandle(env, obj, NULL);
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_NativeObject_toString
+  (JNIEnv * env, jobject obj)
+{
+    Object * mcObj = (Object *) getHandle(env, obj);
+    if (mcObj == NULL) {
+        return (jstring) MC_TO_JAVA(MCSTR("<Uninitialized NativeObject>"));
+    }
+    else {
+        return (jstring) MC_TO_JAVA(mcObj->description());
+    }
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_NativeObject_clone
+  (JNIEnv * env, jobject obj)
+{
+    return MC_TO_JAVA(MC_FROM_JAVA(Object, obj)->copy()->autorelease());
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_NativeObject_serializable
+  (JNIEnv * env, jobject obj)
+{
+    return MC_TO_JAVA(MC_FROM_JAVA(Object, obj)->serializable());
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_NativeObject_objectWithSerializable
+  (JNIEnv * env, jclass cls, jobject serializable)
+{
+    return MC_TO_JAVA(Object::objectWithSerializable(MC_FROM_JAVA(HashMap, serializable)));
+}
diff --git a/src/java/native/com_libmailcore_NativeObject.h b/src/java/native/com_libmailcore_NativeObject.h
new file mode 100644
index 00000000..ae3c7e38
--- /dev/null
+++ b/src/java/native/com_libmailcore_NativeObject.h
@@ -0,0 +1,61 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_NativeObject */
+
+#ifndef _Included_com_libmailcore_NativeObject
+#define _Included_com_libmailcore_NativeObject
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_NativeObject
+ * Method:    initWithNative
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_NativeObject_initWithNative
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_libmailcore_NativeObject
+ * Method:    unsetupNative
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_NativeObject_unsetupNative
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_NativeObject
+ * Method:    toString
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_NativeObject_toString
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_NativeObject
+ * Method:    clone
+ * Signature: ()Ljava/lang/Object;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_NativeObject_clone
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_NativeObject
+ * Method:    serializable
+ * Signature: ()Ljava/util/Map;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_NativeObject_serializable
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_NativeObject
+ * Method:    objectWithSerializable
+ * Signature: (Ljava/util/Map;)Lcom/libmailcore/NativeObject;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_NativeObject_objectWithSerializable
+  (JNIEnv *, jclass, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_Operation.cpp b/src/java/native/com_libmailcore_Operation.cpp
new file mode 100644
index 00000000..dfd8c64c
--- /dev/null
+++ b/src/java/native/com_libmailcore_Operation.cpp
@@ -0,0 +1,64 @@
+#include "com_libmailcore_Operation.h"
+
+#include "TypesUtils.h"
+#include "JavaHandle.h"
+#include "MCOperation.h"
+#include "MCDefines.h"
+
+using namespace mailcore;
+
+#define nativeType Operation
+#define javaType nativeType
+
+class JavaOperationCallback : public Object, public OperationCallback {
+public:
+    JavaOperationCallback(JNIEnv * env, jobject obj) {
+        mEnv = env;
+        mGlobalRef = env->NewGlobalRef(obj);
+    }
+    
+    virtual ~JavaOperationCallback() {
+        if (mGlobalRef != NULL) {
+            mEnv->DeleteGlobalRef(mGlobalRef);
+            mGlobalRef = NULL;
+        }
+    }
+    
+    virtual void operationFinished(Operation * op)
+    {
+        jclass cls = mEnv->GetObjectClass(mGlobalRef);
+        jmethodID mid = mEnv->GetMethodID(cls, "callCallback", "()V");
+        mEnv->CallVoidMethod(mGlobalRef, mid);
+        
+        mEnv->DeleteGlobalRef(mGlobalRef);
+        mGlobalRef = NULL;
+        
+        this->release();
+    }
+    
+private:
+    JNIEnv * mEnv;
+    jobject mGlobalRef;
+};
+
+JNIEXPORT void JNICALL Java_com_libmailcore_Operation_cancel
+  (JNIEnv * env, jobject obj)
+{
+    MC_JAVA_NATIVE_INSTANCE->cancel();
+}
+
+JNIEXPORT jboolean JNICALL Java_com_libmailcore_Operation_isCancelled
+  (JNIEnv * env, jobject obj)
+{
+    return MC_JAVA_BRIDGE_GET_SCALAR(jboolean, isCancelled);
+}
+
+JNIEXPORT void JNICALL Java_com_libmailcore_Operation_nativeStart
+  (JNIEnv * env, jobject obj)
+{
+    JavaOperationCallback * callback = new JavaOperationCallback(env, obj);
+    MC_JAVA_NATIVE_INSTANCE->setCallback(callback);
+    MC_JAVA_NATIVE_INSTANCE->start();
+}
+
+MC_JAVA_BRIDGE
diff --git a/src/java/native/com_libmailcore_Operation.h b/src/java/native/com_libmailcore_Operation.h
new file mode 100644
index 00000000..6bd26753
--- /dev/null
+++ b/src/java/native/com_libmailcore_Operation.h
@@ -0,0 +1,37 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_Operation */
+
+#ifndef _Included_com_libmailcore_Operation
+#define _Included_com_libmailcore_Operation
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_Operation
+ * Method:    cancel
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_Operation_cancel
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_Operation
+ * Method:    isCancelled
+ * Signature: ()Z
+ */
+JNIEXPORT jboolean JNICALL Java_com_libmailcore_Operation_isCancelled
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_Operation
+ * Method:    nativeStart
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_libmailcore_Operation_nativeStart
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_OperationCallback.h b/src/java/native/com_libmailcore_OperationCallback.h
new file mode 100644
index 00000000..50fc1d44
--- /dev/null
+++ b/src/java/native/com_libmailcore_OperationCallback.h
@@ -0,0 +1,13 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_OperationCallback */
+
+#ifndef _Included_com_libmailcore_OperationCallback
+#define _Included_com_libmailcore_OperationCallback
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_OperationQueueListener.h b/src/java/native/com_libmailcore_OperationQueueListener.h
new file mode 100644
index 00000000..6e911d71
--- /dev/null
+++ b/src/java/native/com_libmailcore_OperationQueueListener.h
@@ -0,0 +1,13 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_OperationQueueListener */
+
+#ifndef _Included_com_libmailcore_OperationQueueListener
+#define _Included_com_libmailcore_OperationQueueListener
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_PartType.h b/src/java/native/com_libmailcore_PartType.h
new file mode 100644
index 00000000..d6810d12
--- /dev/null
+++ b/src/java/native/com_libmailcore_PartType.h
@@ -0,0 +1,23 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_PartType */
+
+#ifndef _Included_com_libmailcore_PartType
+#define _Included_com_libmailcore_PartType
+#ifdef __cplusplus
+extern "C" {
+#endif
+#undef com_libmailcore_PartType_PartTypeSingle
+#define com_libmailcore_PartType_PartTypeSingle 0L
+#undef com_libmailcore_PartType_PartTypeMessage
+#define com_libmailcore_PartType_PartTypeMessage 1L
+#undef com_libmailcore_PartType_PartTypeMultipartMixed
+#define com_libmailcore_PartType_PartTypeMultipartMixed 2L
+#undef com_libmailcore_PartType_PartTypeMultipartRelated
+#define com_libmailcore_PartType_PartTypeMultipartRelated 3L
+#undef com_libmailcore_PartType_PartTypeMultipartAlternative
+#define com_libmailcore_PartType_PartTypeMultipartAlternative 4L
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/java/native/com_libmailcore_Range.cpp b/src/java/native/com_libmailcore_Range.cpp
new file mode 100644
index 00000000..a1d657b9
--- /dev/null
+++ b/src/java/native/com_libmailcore_Range.cpp
@@ -0,0 +1,67 @@
+#include "com_libmailcore_Range.h"
+
+#include "TypesUtils.h"
+#include "JavaHandle.h"
+#include "MCRange.h"
+#include "MCDefines.h"
+
+using namespace mailcore;
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Range_removeRange
+  (JNIEnv * env, jobject obj, jobject range)
+{
+    Range mcRange = rangeFromJava(env, obj);
+    Range otherRange = rangeFromJava(env, range);
+    return MC_TO_JAVA(RangeRemoveRange(mcRange, otherRange));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Range_union
+  (JNIEnv * env, jobject obj, jobject range)
+{
+    Range mcRange = rangeFromJava(env, obj);
+    Range otherRange = rangeFromJava(env, range);
+    return MC_TO_JAVA(RangeUnion(mcRange, otherRange));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Range_intersection
+  (JNIEnv * env, jobject obj, jobject range)
+{
+    Range mcRange = rangeFromJava(env, obj);
+    Range otherRange = rangeFromJava(env, range);
+    return rangeToJava(env, RangeIntersection(mcRange, otherRange));
+}
+
+JNIEXPORT jboolean JNICALL Java_com_libmailcore_Range_hasIntersection
+  (JNIEnv * env, jobject obj, jobject range)
+{
+    Range mcRange = rangeFromJava(env, obj);
+    Range otherRange = rangeFromJava(env, range);
+    return (jboolean) RangeHasIntersection(mcRange, otherRange);
+}
+
+JNIEXPORT jlong JNICALL Java_com_libmailcore_Range_leftBound
+  (JNIEnv * env, jobject obj)
+{
+    Range mcRange = rangeFromJava(env, obj);
+    return (jlong) RangeLeftBound(mcRange);
+}
+
+JNIEXPORT jlong JNICALL Java_com_libmailcore_Range_rightBound
+  (JNIEnv * env, jobject obj)
+{
+    Range mcRange = rangeFromJava(env, obj);
+    return (jlong) RangeRightBound(mcRange);
+}
+
+JNIEXPORT jstring JNICALL Java_com_libmailcore_Range_toString
+  (JNIEnv * env, jobject obj)
+{
+    return (jstring) MC_TO_JAVA(RangeToString(rangeFromJava(env, obj)));
+}
+
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Range_rangeWithString
+  (JNIEnv * env, jclass cls, jstring rangeString)
+{
+    Range mcRange = RangeFromString(MC_FROM_JAVA(String, rangeString));
+    return rangeToJava(env, mcRange);
+}
diff --git a/src/java/native/com_libmailcore_Range.h b/src/java/native/com_libmailcore_Range.h
new file mode 100644
index 00000000..f5b03bb3
--- /dev/null
+++ b/src/java/native/com_libmailcore_Range.h
@@ -0,0 +1,77 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_libmailcore_Range */
+
+#ifndef _Included_com_libmailcore_Range
+#define _Included_com_libmailcore_Range
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_libmailcore_Range
+ * Method:    removeRange
+ * Signature: (Lcom/libmailcore/Range;)Lcom/libmailcore/IndexSet;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Range_removeRange
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_Range
+ * Method:    union
+ * Signature: (Lcom/libmailcore/Range;)Lcom/libmailcore/IndexSet;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Range_union
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_Range
+ * Method:    intersection
+ * Signature: (Lcom/libmailcore/Range;)Lcom/libmailcore/Range;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Range_intersection
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_Range
+ * Method:    hasIntersection
+ * Signature: (Lcom/libmailcore/Range;)Z
+ */
+JNIEXPORT jboolean JNICALL Java_com_libmailcore_Range_hasIntersection
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_libmailcore_Range
+ * Method:    leftBound
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_libmailcore_Range_leftBound
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_Range
+ * Method:    rightBound
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_libmailcore_Range_rightBound
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_Range
+ * Method:    toString
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_libmailcore_Range_toString
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_libmailcore_Range
+ * Method:    rangeWithString
+ * Signature: (Ljava/lang/String;)Lcom/libmailcore/Range;
+ */
+JNIEXPORT jobject JNICALL Java_com_libmailcore_Range_rangeWithString
+  (JNIEnv *, jclass, jstring);
+
+#ifdef __cplusplus
+}
+#endif
+#endif