diff --git a/ext/types.h b/ext/types.h
new file mode 100644
--- /dev/null
+++ b/ext/types.h
@@ -0,0 +1,798 @@
+#include <mesos/mesos.hpp>
+
+// some_header_file.h
+#ifndef HS_MESOS_WRAPPERS
+#define HS_MESOS_WRAPPERS
+
+typedef mesos::FrameworkID *FrameworkIDPtr;
+typedef mesos::OfferID *OfferIDPtr;
+typedef mesos::SlaveID *SlaveIDPtr;
+typedef mesos::TaskID *TaskIDPtr;
+typedef mesos::ExecutorID *ExecutorIDPtr;
+typedef mesos::ContainerID *ContainerIDPtr;
+typedef mesos::FrameworkInfo *FrameworkInfoPtr;
+typedef mesos::CommandInfo *CommandInfoPtr;
+typedef mesos::CommandInfo_URI *CommandInfo_URIPtr;
+typedef mesos::ExecutorInfo *ExecutorInfoPtr;
+typedef mesos::MasterInfo *MasterInfoPtr;
+typedef mesos::SlaveInfo *SlaveInfoPtr;
+typedef mesos::Value *ValuePtr;
+typedef mesos::Value_Scalar *Value_ScalarPtr;
+typedef mesos::Value_Range *ValueRangePtr;
+typedef mesos::Value_Ranges *Value_RangesPtr;
+typedef mesos::Value_Set *Value_SetPtr;
+typedef mesos::Value_Text *Value_TextPtr;
+typedef mesos::Attribute *AttributePtr;
+typedef mesos::Resource *ResourcePtr;
+typedef mesos::ResourceStatistics *ResourceStatisticsPtr;
+typedef mesos::ResourceUsage *ResourceUsagePtr;
+typedef mesos::Request *RequestPtr;
+typedef mesos::Offer *OfferPtr;
+typedef mesos::TaskInfo *TaskInfoPtr;
+typedef mesos::TaskStatus *TaskStatusPtr;
+typedef mesos::Filters *FiltersPtr;
+typedef mesos::Environment *EnvironmentPtr;
+typedef mesos::Environment_Variable *EnvironmentVariablePtr;
+typedef mesos::Parameter *ParameterPtr;
+typedef mesos::Parameters *ParametersPtr;
+typedef mesos::Credential *CredentialPtr;
+typedef mesos::CommandInfo_URI *CommandURIPtr;
+typedef mesos::HealthCheck *HealthCheckPtr;
+typedef mesos::ContainerInfo *ContainerInfoPtr;
+typedef mesos::PerfStatistics *PerfStatisticsPtr;
+typedef mesos::Volume *VolumePtr;
+typedef mesos::ContainerInfo *ContainerInfoPtr;
+typedef std::string *StdStringPtr;
+
+extern "C" {
+
+	extern FrameworkIDPtr toFrameworkID(char* bs, int len);
+
+	extern int fromFrameworkID(FrameworkIDPtr p, char** poke);
+
+	extern void destroyFrameworkID(FrameworkIDPtr p);
+
+	extern OfferIDPtr toOfferID(char* bs, int len);
+
+	extern int fromOfferID(OfferIDPtr p, char** poke);
+
+	extern void destroyOfferID(OfferIDPtr p);
+
+	extern SlaveIDPtr toSlaveID(char* bs, int len);
+
+	extern int fromSlaveID(SlaveIDPtr p, char** poke);
+
+	extern void destroySlaveID(SlaveIDPtr p);
+
+	extern TaskIDPtr toTaskID(char* bs, int len);
+
+	extern int fromTaskID(TaskIDPtr p, char** poke);
+
+	extern void destroyTaskID(TaskIDPtr p);
+
+	extern ExecutorIDPtr toExecutorID(char* bs, int len);
+
+	extern int fromExecutorID(ExecutorIDPtr p, char** poke);
+
+	extern void destroyExecutorID(ExecutorIDPtr p);
+
+	extern ContainerIDPtr toContainerID(char* bs, int len);
+
+	extern int fromContainerID(ContainerIDPtr p, char** poke);
+
+	extern void destroyContainerID(ContainerIDPtr p);
+
+	extern FrameworkInfoPtr toFrameworkInfo(char* user,
+						int userLen,
+						char* name,
+						int nameLen,
+						FrameworkIDPtr* frameworkID,
+						double* failoverTimeout,
+						bool* checkpoint,
+						char* role,
+						int roleLen,
+						char* hostname,
+						int hostLen,
+						char* principal,
+						int principalLen);
+
+	extern void fromFrameworkInfo(FrameworkInfoPtr info,
+				      char** user,
+				      int* userLen,
+				      char** name,
+				      int* nameLen,
+				      FrameworkIDPtr* frameworkID,
+				      bool* failoverSet,
+				      double* failoverTimeout,
+				      bool* checkpointSet,
+				      bool* checkpoint,
+				      char** role,
+				      int* roleLen,
+				      char** hostname,
+				      int* hostLen,
+				      char** principal,
+				      int* principalLen);
+
+	extern void destroyFrameworkInfo(FrameworkInfoPtr info);
+
+	extern CommandURIPtr toCommandURI(char* cmd,
+					  int cmdLen,
+					  bool* executable,
+					  bool* extract);
+
+	extern void fromCommandURI(CommandURIPtr commandURI,
+				   char** cmd,
+				   int* cmdLen,
+				   bool* executableSet,
+				   bool* executable,
+				   bool* extractSet,
+				   bool* extract);
+
+	extern void destroyCommandURI(CommandURIPtr commandURI);
+
+  extern MasterInfoPtr toMasterInfo(char* infoID,
+				    int infoIDLen,
+				    unsigned int infoIP,
+				    unsigned int* infoPort,
+				    char* pid,
+				    int pidLen,
+				    char* hostname,
+				    int hostnameLen);
+
+  extern void fromMasterInfo(MasterInfoPtr info,
+			     char** infoID,
+			     int* infoIDLen,
+			     unsigned int* infoIP,
+			     unsigned int* infoPort,
+			     char** pid,
+			     int* pidLen,
+			     char** hostname,
+			     int* hostnameLen);
+
+  extern void destroyMasterInfo(MasterInfoPtr info);
+  
+	extern SlaveInfoPtr toSlaveInfo(char* hostname,
+		int hostnameLen,
+		unsigned int* port,
+		ResourcePtr* resources,
+		int resourcesLen,
+		AttributePtr* attributes,
+		int attributeLen,
+		SlaveIDPtr slaveID,
+		bool* checkpoint);
+
+	extern void fromSlaveInfo(SlaveInfoPtr slaveInfo,
+		char** hostname,
+		int* hostnameLen,
+		bool* portSet,
+		unsigned int* port,
+		ResourcePtr** resources,
+		int* resourcesLen,
+		AttributePtr** attributes,
+		int* attributeLen,
+		SlaveIDPtr* slaveID,
+		bool* checkpointSet,
+		bool* checkpoint);
+
+	extern void destroySlaveInfo(SlaveInfoPtr slaveInfo);
+
+	extern OfferPtr toOffer(OfferIDPtr offerID,
+		FrameworkIDPtr frameworkID,
+		SlaveIDPtr slaveID,
+		char* hostname,
+		int hostnameLen,
+		ResourcePtr* resources,
+		int resourceLen,
+		AttributePtr* attributes,
+		int attributeLen,
+		ExecutorIDPtr* executors,
+		int executorLen);
+
+	extern void fromOffer(OfferPtr offer,
+		OfferIDPtr* offerID,
+		FrameworkIDPtr* frameworkID,
+		SlaveIDPtr* slaveID,
+		char** hostname,
+		int* hostnameLen,
+		ResourcePtr** resources,
+		int* resourceLen,
+		AttributePtr** attributes,
+		int* attributeLen,
+		ExecutorIDPtr** executors,
+		int* executorLen);
+
+	extern void destroyOffer(OfferPtr offer);
+
+  extern TaskInfoPtr toTaskInfo(char* infoName,
+				int infoNameLen,
+				TaskIDPtr taskID,
+				SlaveIDPtr slaveID,
+				ResourcePtr* resources,
+				int resourcesLen,
+				ExecutorInfoPtr executorInfo,
+				CommandInfoPtr commandInfo,
+				char* data,
+				int dataLen,
+				ContainerInfoPtr containerInfo,
+				HealthCheckPtr healthCheck
+				);
+
+  extern void fromTaskInfo(TaskInfoPtr taskInfo,
+			   char** infoName,
+			   int* infoNameLen,
+			   TaskIDPtr* taskID,
+			   SlaveIDPtr* slaveID,
+			   ResourcePtr** resources,
+			   int* resourcesLen,
+			   ExecutorInfoPtr* executorInfo,
+			   CommandInfoPtr* commandInfo,
+			   char** data,
+			   int* dataLen,
+			   ContainerInfoPtr* containerInfo,
+			   HealthCheckPtr* healthCheck
+			   );
+
+  extern void destroyTaskInfo(TaskInfoPtr taskInfo);
+  
+  extern TaskStatusPtr toTaskStatus(TaskIDPtr taskID,
+				    int state,
+				    char* message,
+				    int messageLen,
+				    char* data,
+				    int dataLen,
+				    SlaveIDPtr slaveID,
+				    ExecutorIDPtr executorID,
+				    double* timestamp,
+				    bool* healthCheck);
+
+	extern void fromTaskStatus(TaskStatusPtr status,
+				   TaskIDPtr* taskID,
+				   int* state,
+				   char** message,
+				   int* messageLen,
+				   char** data,
+				   int* dataLen,
+				   SlaveIDPtr* slaveID,
+				   ExecutorIDPtr* executorID,
+				   bool* timestampSet,
+				   double* timestamp,
+				   bool* healthCheckSet,
+				   bool* healthCheck);
+
+	extern void destroyTaskStatus(TaskStatusPtr taskStatus);	
+
+	extern FiltersPtr toFilters(double* refuseSeconds);
+
+	extern void fromFilters(FiltersPtr filters,
+		bool* refusalSet,
+		double* refuseSeconds);
+
+	extern void destroyFilters(FiltersPtr filters);
+
+	extern EnvironmentVariablePtr toEnvironmentVariable(char* key,
+		int keyLen,
+		char* value,
+		int valueLen);
+
+	extern void fromEnvironmentVariable(EnvironmentVariablePtr var,
+		char** key,
+		int* keyLen,
+		char** value,
+		int* valueLen);
+
+	extern void destroyEnvironmentVariable(EnvironmentVariablePtr env);
+
+
+	extern EnvironmentPtr toEnvironment(EnvironmentVariablePtr* env,
+		int envLen);
+
+	extern void fromEnvironment(EnvironmentPtr env,
+		EnvironmentVariablePtr** variables,
+		int* envLen);
+
+	extern void destroyEnvironment(EnvironmentPtr env);
+
+	extern CredentialPtr toCredential(char* principal,
+		int principalLen,
+		char* secret,
+		int secretLen);
+
+	extern void fromCredential(
+		CredentialPtr credential,
+		char** principal,
+		int* principalLen,
+		char** secret,
+		int* secretLen);
+
+	extern void destroyCredential(CredentialPtr credential);
+
+	extern ResourcePtr toResource(char* name,
+		int nameLen,
+		ValuePtr value,
+		char* role,
+		int roleLen);
+
+	extern void fromResource(ResourcePtr resource,
+		char** name,
+		int* nameLen,
+		ValuePtr* value,
+		char** role,
+		int* roleLen);
+
+	extern void destroyResource(ResourcePtr resource);
+
+  extern ExecutorInfoPtr toExecutorInfo(ExecutorIDPtr executorID,
+					FrameworkIDPtr frameworkID,
+					CommandInfoPtr commandInfo,
+					ContainerInfoPtr containerInfo,
+					ResourcePtr* resources,
+					int resourceLen,
+					char* name,
+					int nameLen,
+					char* source,
+					int sourceLen,
+					char* data,
+					int dataLen);
+
+  extern void fromExecutorInfo(ExecutorInfoPtr executorInfo,
+			       ExecutorIDPtr* executorID,
+			       FrameworkIDPtr* frameworkID,
+			       CommandInfoPtr* commandInfo,
+			       ContainerInfoPtr* containerInfo,
+			       ResourcePtr** resources,
+			       int* resourcesLen,
+			       char** name,
+			       int* nameLen,
+			       char** source,
+			       int* sourceLen,
+			       char** data,
+			       int* dataLen);
+
+	extern void destroyExecutorInfo(ExecutorInfoPtr executorInfo);
+
+	extern AttributePtr toAttribute(char* name,
+		int nameLen,
+		ValuePtr value);
+	extern void fromAttribute(AttributePtr attribute,
+		char** name,
+		int* nameLen,
+		ValuePtr* value);
+	extern void destroyAttribute(AttributePtr attribute);
+
+	extern RequestPtr toRequest(SlaveIDPtr slaveID,
+		ResourcePtr* resources,
+		int resourceLen);
+
+	extern void fromRequest(RequestPtr request,
+		SlaveIDPtr* slaveID,
+		ResourcePtr** resources,
+		int* resourceLen);
+
+	extern void destroyRequest(RequestPtr request);
+
+	extern ValuePtr toValue(int type,
+		double scalar,
+		ValueRangePtr* lows,
+		int rangeLen,
+		StdStringPtr* strings,
+		int stringsLen,
+		char* text,
+		int textLen);
+
+	extern void fromValue(ValuePtr value,
+		int* type,
+		double* scalar,
+		ValueRangePtr** ranges,
+		int* rangeLen,
+		StdStringPtr** strings,
+		int* stringsLen,
+		char** text,
+		int* textLen);
+
+	extern void destroyValue(ValuePtr value);
+
+	extern CommandInfoPtr toCommandInfo(CommandInfo_URIPtr* uris,
+					    int urisLen,
+					    EnvironmentPtr environment,
+					    bool shell,
+					    char* value,
+					    int valueLen,
+					    StdStringPtr* args,
+					    int argsLen,
+					    char* username,
+					    int usernameLen);
+
+	extern void fromCommandInfo(CommandInfoPtr info,
+				    CommandInfo_URIPtr** uris,
+				    int* urisLen,
+				    EnvironmentPtr* environment,
+				    bool* shell,
+				    char** value,
+				    int* valueLen,
+				    StdStringPtr** args,
+				    int* argsLen,
+				    char** username,
+				    int* usernameLen);
+
+	extern void destroyCommandInfo(CommandInfoPtr info);
+
+	extern ResourceUsagePtr toResourceUsage(SlaveIDPtr slaveID,
+		FrameworkIDPtr frameworkID,
+		ExecutorIDPtr executorID,
+		char* executorName,
+		int nameLen,
+		TaskIDPtr taskID,
+		ResourceStatisticsPtr statistics);
+	
+	extern void fromResourceUsage(ResourceUsagePtr usage,
+		SlaveIDPtr* slaveID,
+		FrameworkIDPtr* frameworkID,
+		ExecutorIDPtr* executorID,
+		char** executorName,
+		int* nameLen,
+		TaskIDPtr* taskID,
+		ResourceStatisticsPtr* statistics);
+
+	extern void destroyResourceUsage(ResourceUsagePtr usage);
+
+	extern OfferPtr toOffer(OfferIDPtr offerID,
+		FrameworkIDPtr frameworkID,
+		SlaveIDPtr slaveID,
+		char* hostname,
+		int hostnameLen,
+		ResourcePtr* resources,
+		int resourcesLen,
+		AttributePtr* attributes,
+		int attributeLen,
+		ExecutorIDPtr* executorIDs,
+		int idsLen);
+
+	void fromOffer(OfferPtr offer,
+		OfferIDPtr* offerID,
+		FrameworkIDPtr* frameworkID,
+		SlaveIDPtr* slaveID,
+		char** hostname,
+		int* hostnameLen,
+		ResourcePtr** resources,
+		int* resourcesLen,
+		AttributePtr** attributes,
+		int* attributesLen,
+		ExecutorIDPtr** executorIDs,
+		int* idsLen);
+
+	extern void destroyOffer(OfferPtr offer);
+  
+  extern void destroyResourceStatistics(ResourceStatisticsPtr statistics);
+
+  extern ResourceStatisticsPtr toResourceStatistics(double timestamp,
+						    double* cpusUserTimeSecs,
+						    double* cpusSystemTimeSecs,
+						    double cpusLimit,
+						    unsigned int* cpusPeriods,
+						    unsigned int* cpusThrottled,
+						    double* cpusThrottledTimeSecs,
+						    unsigned long* memoryResidentSetSize,
+						    unsigned long* memoryLimitBytes,
+						    unsigned long* memoryFileBytes,
+						    unsigned long* memoryAnonymousBytes,
+						    unsigned long* memoryMappedFileBytes,
+						    PerfStatisticsPtr perfStatistics,
+						    unsigned long* netRxPackets,
+						    unsigned long* netRxBytes,
+						    unsigned long* netRxErrors,
+						    unsigned long* netRxDropped,
+						    unsigned long* netTxPackets,
+						    unsigned long* netTxBytes,
+						    unsigned long* netTxErrors,
+						    unsigned long* netTxDropped
+						    );
+
+  extern void fromResourceStatistics(ResourceStatisticsPtr stats,
+				     double* timestamp,
+				     double* cpusUserTimeSecs,
+				     bool* cpusUserTimeSecsSet,
+				     double* cpusSystemTimeSecs,
+				     bool* cpusSystemTimeSecsSet,
+				     double* cpusLimit,
+				     unsigned int* cpusPeriods,
+				     bool* cpusPeriodsSet,
+				     unsigned int* cpusThrottled,
+				     bool* cpusThrottledSet,
+				     double* cpusThrottledTimeSecs,
+				     bool* cpusThrottledTimeSecsSet,
+				     unsigned long* memoryResidentSetSize,
+				     bool* memoryResidentSetSizeSet,
+				     unsigned long* memoryLimitBytes,
+				     bool* memoryLimitBytesSet,
+				     unsigned long* memoryFileBytes,
+				     bool* memoryFileBytesSet,
+				     unsigned long* memoryAnonymousBytes,
+				     bool* memoryAnonymousBytesSet,
+				     unsigned long* memoryMappedFileBytes,
+				     bool* memoryMappedFileBytesSet,
+				     PerfStatisticsPtr* perfStatistics,
+				     unsigned long* netRxPackets,
+				     bool* netRxPacketsSet, 
+				     unsigned long* netRxBytes,
+				     bool* netRxBytesSet, 
+				     unsigned long* netRxErrors,
+				     bool* netRxErrorsSet, 
+				     unsigned long* netRxDropped,
+				     bool* netRxDroppedSet, 
+				     unsigned long* netTxPackets,
+				     bool* netTxPacketsSet, 
+				     unsigned long* netTxBytes,
+				     bool* netTxBytesSet, 
+				     unsigned long* netTxErrors,
+				     bool* netTxErrorsSet, 
+				     unsigned long* netTxDropped,
+				     bool* netTxDroppedSet
+				     );
+  
+
+	extern ParameterPtr toParameter(char* key,
+		int keyLen,
+		char* value,
+		int valueLen);
+	extern void fromParameter(ParameterPtr parameter,
+		char** keyP,
+		int* keyLenP,
+		char** valueP,
+		int* valueLenP);
+	extern void destroyParameter(ParameterPtr parameter);
+
+	extern ParametersPtr toParameters(ParameterPtr* parameters,
+		int pLen);
+	extern void fromParameters(ParametersPtr params,
+		ParameterPtr** parameters,
+		int* pLen);
+	extern void destroyParameters(ParametersPtr params);
+
+	extern StdStringPtr toStdString(char* str,
+		int strLen);
+
+	extern void fromStdString(StdStringPtr sp,
+		char** str,
+		int* strLen);
+
+	extern void destroyStdString(StdStringPtr sp);
+
+	extern ValueRangePtr toRange(unsigned long low,
+		unsigned long high);
+
+	extern void fromRange(ValueRangePtr range,
+		unsigned long* lowP,
+		unsigned long* highP);
+
+	extern void destroyRange(ValueRangePtr range);
+
+  extern PerfStatisticsPtr toPerfStatistics(
+					    double timestamp,
+					    double duration,
+					    unsigned long* cycles,
+					    unsigned long* stalledCyclesFrontend,
+					    unsigned long* stalledCyclesBackend,
+					    unsigned long* instructions,
+					    unsigned long* cacheReferences,
+					    unsigned long* cacheMisses,
+					    unsigned long* branches,
+					    unsigned long* branchMisses,
+					    unsigned long* busCycles,
+					    unsigned long* refCycles,
+					    double* cpuClock,
+					    double* taskClock,
+					    unsigned long* pageFaults,
+					    unsigned long* minorFaults,
+					    unsigned long* majorFaults,
+					    unsigned long* contextSwitches,
+					    unsigned long* cpuMigrations,
+					    unsigned long* alignmentFaults,
+					    unsigned long* emulationFaults,
+					    unsigned long* l1DcacheLoads,
+					    unsigned long* l1DcacheLoadMisses,
+					    unsigned long* l1DcacheStores,
+					    unsigned long* l1DcacheStoreMisses,
+					    unsigned long* l1DcachePrefetches,
+					    unsigned long* l1DcachePrefetchMisses,
+					    unsigned long* l1IcacheLoads,
+					    unsigned long* l1IcacheLoadMisses,
+					    unsigned long* l1IcachePrefetches,
+					    unsigned long* l1IcachePrefetchMisses,
+					    unsigned long* llcLoads,
+					    unsigned long* llcLoadMisses,
+					    unsigned long* llcStores,
+					    unsigned long* llcStoreMisses,
+					    unsigned long* llcPrefetches,
+					    unsigned long* llcPrefetchMisses,
+					    unsigned long* dtlbLoads,
+					    unsigned long* dtlbLoadMisses,
+					    unsigned long* dtlbStores,
+					    unsigned long* dtlbStoreMisses,
+					    unsigned long* dtlbPrefetches,
+					    unsigned long* dtlbPrefetchMisses,
+					    unsigned long* itlbLoads,
+					    unsigned long* itlbLoadMisses,
+					    unsigned long* branchLoads,
+					    unsigned long* branchLoadMisses,
+					    unsigned long* nodeLoads,
+					    unsigned long* nodeLoadMisses,
+					    unsigned long* nodeStores,
+					    unsigned long* nodeStoreMisses,
+					    unsigned long* nodePrefetches,
+					    unsigned long* nodePrefetchMisses
+					    );
+
+extern void fromPerfStatistics(PerfStatisticsPtr perf,
+			       double* timestamp,
+			       double* duration,
+			       unsigned long* cycles,
+			       bool* cyclesSet,
+			       unsigned long* stalledCyclesFrontend,
+			       bool* stalledCyclesFrontendSet,
+			       unsigned long* stalledCyclesBackend,
+			       bool* stalledCyclesBackendSet,
+			       unsigned long* instructions,
+			       bool* instructionsSet,
+			       unsigned long* cacheReferences,
+			       bool* cacheReferencesSet,
+			       unsigned long* cacheMisses,
+			       bool* cacheMissesSet,
+			       unsigned long* branches,
+			       bool* branchesSet,
+			       unsigned long* branchMisses,
+			       bool* branchMissesSet,
+			       unsigned long* busCycles,
+			       bool* busCyclesSet,
+			       unsigned long* refCycles,
+			       bool* refCyclesSet,
+			       double* cpuClock,
+			       bool* cpuClockSet,
+			       double* taskClock,
+			       bool* taskClockSet,
+			       unsigned long* pageFaults,
+			       bool* pageFaultsSet,
+			       unsigned long* minorFaults,
+			       bool* minorFaultsSet,
+			       unsigned long* majorFaults,
+			       bool* majorFaultsSet,
+			       unsigned long* contextSwitches,
+			       bool* contextSwitchesSet,
+			       unsigned long* cpuMigrations,
+			       bool* cpuMigrationsSet,
+			       unsigned long* alignmentFaults,
+			       bool* alignmentFaultsSet,
+			       unsigned long* emulationFaults,
+			       bool* emulationFaultsSet,
+			       unsigned long* l1DcacheLoads,
+			       bool* l1DcacheLoadsSet,
+			       unsigned long* l1DcacheLoadMisses,
+			       bool* l1DcacheLoadMissesSet,
+			       unsigned long* l1DcacheStores,
+			       bool* l1DcacheStoresSet,
+			       unsigned long* l1DcacheStoreMisses,
+			       bool* l1DcacheStoreMissesSet,
+			       unsigned long* l1DcachePrefetches,
+			       bool* l1DcachePrefetchesSet,
+			       unsigned long* l1DcachePrefetchMisses,
+			       bool* l1DcachePrefetchMissesSet,
+			       unsigned long* l1IcacheLoads,
+			       bool* l1IcacheLoadsSet,
+			       unsigned long* l1IcacheLoadMisses,
+			       bool* l1IcacheLoadMissesSet,
+			       unsigned long* l1IcachePrefetches,
+			       bool* l1IcachePrefetchesSet,
+			       unsigned long* l1IcachePrefetchMisses,
+			       bool* l1IcachePrefetchMissesSet,
+			       unsigned long* llcLoads,
+			       bool* llcLoadsSet,
+			       unsigned long* llcLoadMisses,
+			       bool* llcLoadMissesSet,
+			       unsigned long* llcStores,
+			       bool* llcStoresSet,
+			       unsigned long* llcStoreMisses,
+			       bool* llcStoreMissesSet,
+			       unsigned long* llcPrefetches,
+			       bool* llcPrefetchesSet,
+			       unsigned long* llcPrefetchMisses,
+			       bool* llcPrefetchMissesSet,
+			       unsigned long* dtlbLoads,
+			       bool* dtlbLoadsSet,
+			       unsigned long* dtlbLoadMisses,
+			       bool* dtlbLoadMissesSet,
+			       unsigned long* dtlbStores,
+			       bool* dtlbStoresSet,
+			       unsigned long* dtlbStoreMisses,
+			       bool* dtlbStoreMissesSet,
+			       unsigned long* dtlbPrefetches,
+			       bool* dtlbPrefetchesSet,
+			       unsigned long* dtlbPrefetchMisses,
+			       bool* dtlbPrefetchMissesSet,
+			       unsigned long* itlbLoads,
+			       bool* itlbLoadsSet,
+			       unsigned long* itlbLoadMisses,
+			       bool* itlbLoadMissesSet,
+			       unsigned long* branchLoads,
+			       bool* branchLoadsSet,
+			       unsigned long* branchLoadMisses,
+			       bool* branchLoadMissesSet,
+			       unsigned long* nodeLoads,
+			       bool* nodeLoadsSet,
+			       unsigned long* nodeLoadMisses,
+			       bool* nodeLoadMissesSet,
+			       unsigned long* nodeStores,
+			       bool* nodeStoresSet,
+			       unsigned long* nodeStoreMisses,
+			       bool* nodeStoreMissesSet,
+			       unsigned long* nodePrefetches,
+			       bool* nodePrefetchesSet,
+			       unsigned long* nodePrefetchMisses,
+			       bool* nodePrefetchMissesSet);
+
+  extern void destroyPerfStatistics(PerfStatisticsPtr perf);
+
+  extern ContainerInfoPtr toContainerInfo (int type,
+					   char* image,
+					   int imageLen,
+					   VolumePtr* volumes,
+					   int volumesLen);
+
+  extern void fromContainerInfo (ContainerInfoPtr info,
+				 int* type,
+				 char** image,
+				 int* imageLen,
+				 VolumePtr** volumes,
+				 int* volumesLen);
+
+  extern void destroyContainerInfo (ContainerInfoPtr containerInfo);
+
+  extern VolumePtr toVolume (char* containerPath,
+			     int containerPathLen,
+			     char* hostPath,
+			     int hostPathLen,
+			     int mode);
+
+  extern void fromVolume (VolumePtr p,
+			  char** containerPath,
+			  int* containerPathLen,
+			  char** hostPath,
+			  int* hostPathLen,
+			  int* mode);
+
+  extern void destroyVolume(VolumePtr volume);
+
+  extern HealthCheckPtr toHealthCheck (bool hasHTTP,
+			      int port,
+			      char* httpPath,
+			      int httpPathSize,
+			      unsigned int* statuses,
+			      int statusesSize,
+			      double* delaySeconds,
+			      double* intervalSeconds,
+			      double* timeoutSeconds,
+			      unsigned int* consecutiveFailures,
+			      double* gracePeriodSeconds,
+				       CommandInfoPtr command);
+  
+  extern void fromHealthCheck (HealthCheckPtr p,
+		    bool* hasHTTP,
+		    int* port,
+		    char** httpPath,
+		    int* httpPathSize,
+		    unsigned int** statuses,
+		    int* statusesSize,
+		    double* delaySeconds,
+		    bool* delaySecondsSet,
+		    double* intervalSeconds,
+		    bool* intervalSecondsSet,
+		    double* timeoutSeconds,
+		    bool* timeoutSecondsSet,
+		    unsigned int* consecutiveFailures,
+		    bool* consecutiveFailuresSet,
+		    double* gracePeriodSeconds,
+		    bool* gracePeriodSecondsSet,
+			       CommandInfoPtr* command);
+
+  extern void destroyHealthCheck (HealthCheckPtr p);
+};
+
+#endif
diff --git a/hs-mesos.cabal b/hs-mesos.cabal
--- a/hs-mesos.cabal
+++ b/hs-mesos.cabal
@@ -1,5 +1,5 @@
 name:                hs-mesos
-version:             0.20.0.2
+version:             0.20.1.0
 
 description:         Bindings to the Apache Mesos platform.
                      .
@@ -23,6 +23,7 @@
                        System.Mesos.Types,
                        System.Mesos.Internal,
                        System.Mesos.TaskStatus,
+                       System.Mesos.Lens,
                        System.Mesos.Raw,
                        System.Mesos.Raw.Attribute,
                        System.Mesos.Raw.CommandInfo,
@@ -59,12 +60,13 @@
                        System.Mesos.Raw.Value,
                        System.Mesos.Raw.Volume
   -- other-extensions:    
-  build-depends:       base >=4.7 && < 5, bytestring, lens, managed
+  build-depends:       base >=4.7 && < 5, bytestring, lens, managed, template-haskell
   hs-source-dirs:      src
   default-language:    Haskell2010
   include-dirs:        ext, /usr/include, /usr/local/include/mesos
   install-includes:    ext/executor.h,
-                       ext/scheduler.h
+                       ext/scheduler.h,
+                       ext/types.h
   c-sources:           ext/executor.cpp,
                        ext/scheduler.cpp,
                        ext/types/attribute.cpp,
@@ -101,7 +103,7 @@
                        ext/types/value.cpp,
                        ext/types/volume.cpp
 
-  extra-libraries:     mesos stdc++
+  extra-libraries:     mesos stdc++ protobuf
   extra-lib-dirs:      /usr/local/lib
   cc-options:          -fPIC -std=c++11
   ghc-options:         -fPIC -funbox-strict-fields
diff --git a/src/System/Mesos/Internal.hs b/src/System/Mesos/Internal.hs
--- a/src/System/Mesos/Internal.hs
+++ b/src/System/Mesos/Internal.hs
@@ -39,19 +39,25 @@
   liftIO,
   ToID,
   FromID,
-  defEq
+  defEq,
+  makePrefixFields
 ) where
 import           Control.Monad.Managed
 
 
 import           Control.Applicative
-import           Data.ByteString        (ByteString, packCStringLen)
-import           Data.ByteString.Unsafe (unsafeUseAsCStringLen)
+import           Control.Lens
+import           Control.Lens.TH
+import           Data.ByteString            (ByteString, packCStringLen)
+import           Data.ByteString.Unsafe     (unsafeUseAsCStringLen)
+import           Data.Char                  (toLower)
+import qualified Data.List                  as L
 import           Data.Word
-import           Foreign.C              hiding (peekCString)
-import qualified Foreign.Marshal        as Ptr
-import qualified Foreign.Ptr            as Ptr
-import qualified Foreign.Storable       as Ptr
+import           Foreign.C                  hiding (peekCString)
+import qualified Foreign.Marshal            as Ptr
+import qualified Foreign.Ptr                as Ptr
+import qualified Foreign.Storable           as Ptr
+import           Language.Haskell.TH.Syntax (Name (..), OccName (..))
 import           System.Mesos.Types
 
 class CPPValue a where
@@ -167,3 +173,11 @@
 
 type ToID a = Ptr.Ptr CChar -> CInt -> IO a
 type FromID a = a -> Ptr.Ptr (Ptr.Ptr CChar) -> IO CInt
+
+makePrefixFields p = makeLensesWith tweakedRules
+  where
+    tweakedRules = defaultFieldRules & lensField .~ (\ns n -> baseF (map downcasePrefix ns) (downcasePrefix n))
+    baseF = defaultFieldRules ^. lensField
+    downcasePrefix n@(Name (OccName s) f) = case L.stripPrefix p s of
+                                              Nothing -> n
+                                              Just r -> Name (OccName (map toLower p ++ r)) f
diff --git a/src/System/Mesos/Lens.hs b/src/System/Mesos/Lens.hs
new file mode 100644
--- /dev/null
+++ b/src/System/Mesos/Lens.hs
@@ -0,0 +1,47 @@
+{-# LANGUAGE FlexibleInstances      #-}
+{-# LANGUAGE FunctionalDependencies #-}
+{-# LANGUAGE MultiParamTypeClasses  #-}
+{-# LANGUAGE TemplateHaskell        #-}
+{-# LANGUAGE TypeSynonymInstances   #-}
+-- | Currently just raw TH-generated 'Lens'es and 'Prism's. FUNCTION & CLASS NAMES IN THIS FILE ARE EXTREMELY LIKELY TO CHANGE IN FUTURE RELEASES.
+module System.Mesos.Lens where
+
+import           Control.Lens.TH
+import           System.Mesos.Internal (makePrefixFields)
+import           System.Mesos.Types
+
+makePrisms ''TaskState
+makePrisms ''Status
+makeFields ''FrameworkID
+makeFields ''OfferID
+makeFields ''SlaveID
+makeFields ''TaskID
+makeFields ''ExecutorID
+makeFields ''ContainerID
+makeFields ''FrameworkInfo
+makeFields ''HealthCheckStrategy
+makePrisms ''HealthCheckStrategy
+makePrefixFields "healthCheck" ''HealthCheck
+makePrefixFields "command" ''CommandInfo
+makePrefixFields "commandURI" ''CommandURI
+makePrisms ''CommandValue
+makePrefixFields "executorInfo" ''ExecutorInfo
+makePrefixFields "masterInfo" ''MasterInfo
+makePrefixFields "slaveInfo" ''SlaveInfo
+makeLenses ''Filters
+makePrisms ''Value
+makeFields ''Resource
+makePrefixFields "resource" ''ResourceStatistics
+makeFields ''ResourceUsage
+makePrefixFields "performanceStatistics" ''PerformanceStatistics
+makeFields ''Request
+makeFields ''Offer
+makePrisms ''TaskExecutionInfo
+makeFields ''TaskInfo
+makePrefixFields "taskStatus" ''TaskStatus
+makeFields ''Credential
+makePrisms ''Mode
+makeFields ''Volume
+makeFields ''ContainerType
+makePrisms ''ContainerType
+makePrefixFields "containerInfo" ''ContainerInfo
diff --git a/src/System/Mesos/Raw/TaskInfo.hs b/src/System/Mesos/Raw/TaskInfo.hs
--- a/src/System/Mesos/Raw/TaskInfo.hs
+++ b/src/System/Mesos/Raw/TaskInfo.hs
@@ -48,7 +48,7 @@
 instance CPPValue TaskInfo where
 
   marshal t = do
-    (np, nl) <- cstring $ taskInfoName t
+    (np, nl) <- cstring $ taskName t
     rps <- mapM cppValue (taskResources t)
     tid <- cppValue $ taskID t
     sid <- cppValue $ taskSlaveID t
diff --git a/src/System/Mesos/Types.hs b/src/System/Mesos/Types.hs
--- a/src/System/Mesos/Types.hs
+++ b/src/System/Mesos/Types.hs
@@ -497,7 +497,7 @@
 -- A different executor can be used to launch this task, and subsequent tasks
 -- meant for the same executor can reuse the same ExecutorInfo struct.
 data TaskInfo = TaskInfo
-  { taskInfoName       :: !ByteString
+  { taskName           :: !ByteString
   , taskID             :: !TaskID
   , taskSlaveID        :: !SlaveID
   , taskResources      :: ![Resource]
diff --git a/test/TestExecutor.hs b/test/TestExecutor.hs
--- a/test/TestExecutor.hs
+++ b/test/TestExecutor.hs
@@ -1,11 +1,11 @@
 {-# LANGUAGE OverloadedStrings #-}
 module Main where
-import Control.Monad
-import Data.Monoid
-import System.Exit
-import System.Mesos.Executor
-import System.Mesos.TaskStatus
-import System.Mesos.Types
+import           Control.Monad
+import           Data.Monoid
+import           System.Exit
+import           System.Mesos.Executor
+import           System.Mesos.TaskStatus
+import           System.Mesos.Types
 
 data TestExecutor = TestExecutor
 instance ToExecutor TestExecutor where
diff --git a/test/TestFramework.hs b/test/TestFramework.hs
--- a/test/TestFramework.hs
+++ b/test/TestFramework.hs
@@ -29,7 +29,7 @@
   }
 
 executorSettings fid = e { executorName = Just "Test Executor (Haskell)"}
-  where e = executorInfo (ExecutorID "default") fid (CommandInfo [] Nothing (ShellCommand "/Users/ian/Code/personal/hs-mesos/dist/build/test-executor/test-executor") Nothing) requiredResources
+  where e = executorInfo (ExecutorID "default") fid (commandInfo $ ShellCommand "/Users/ian/Code/personal/hs-mesos/dist/build/test-executor/test-executor") requiredResources
 
 instance ToScheduler TestScheduler where
   registered _ _ _ _ = putStrLn "Registered!"